[Script Info]
Title: 
[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue: 0,0:00:00.00,0:00:04.39,Default,,0000,0000,0000,,Neste segmento perguntamos se podemos construir a partir de cifras de bloco simples
Dialogue: 0,0:00:04.39,0:00:09.46,Default,,0000,0000,0000,,primitivos como pseudo geradores aleatórios. A resposta é sim. Então, para começar, vamos
Dialogue: 0,0:00:09.46,0:00:14.22,Default,,0000,0000,0000,,perguntar se podemos construir pseudo funções aleatórias em vez de pseudo-aleatório
Dialogue: 0,0:00:14.22,0:00:18.79,Default,,0000,0000,0000,,permutações de um gerador pseudo-aleatório. Podemos construir um PRF de um PRG?
Dialogue: 0,0:00:18.79,0:00:23.87,Default,,0000,0000,0000,,Nosso objetivo final que é construir uma cifra de bloco que é um PRP. E nós vamos chegar
Dialogue: 0,0:00:23.87,0:00:29.13,Default,,0000,0000,0000,,a que, no final. Ok, agora vamos construir um PRF. Então vamos começar com um PRG que
Dialogue: 0,0:00:29.13,0:00:34.59,Default,,0000,0000,0000,,dobra suas entradas de modo as sementes para o PRG é um elemento em K ea saída é
Dialogue: 0,0:00:34.59,0:00:39.42,Default,,0000,0000,0000,,, na verdade, dois elementos em K. Portanto, aqui temos um esquema do gerador, que
Dialogue: 0,0:00:39.42,0:00:44.30,Default,,0000,0000,0000,,basicamente tem sua entrada de C e K, e saídas de dois elementos, em K, como sua saída.
Dialogue: 0,0:00:44.30,0:00:48.99,Default,,0000,0000,0000,,E agora o que significa para essa pureza para ser seguro, lembre-se isto significa que
Dialogue: 0,0:00:48.99,0:00:52.96,Default,,0000,0000,0000,,essencialmente a saída é indistinguível de um elemento aleatório
Dialogue: 0,0:00:52.96,0:00:58.36,Default,,0000,0000,0000,,dentro de K quadrado Agora verifica-se que é muito fácil definir basicamente o que é
Dialogue: 0,0:00:58.36,0:01:03.46,Default,,0000,0000,0000,,chamado uma PRF bit um a partir deste PRG. Então, o que é um pouco um PRF é basicamente um PRF
Dialogue: 0,0:01:03.46,0:01:08.36,Default,,0000,0000,0000,,domínio que é apenas um bit. Ok, então é um PRF que só leva um pouco como
Dialogue: 0,0:01:08.36,0:01:13.46,Default,,0000,0000,0000,,de entrada. Ok, ea forma como vamos fazê-lo é que vai dizer é se o X bit de entrada é zero
Dialogue: 0,0:01:13.46,0:01:18.63,Default,,0000,0000,0000,,eu vou colocar a saída esquerda e se o bit de entrada X é um, então eu vou colocar o direito
Dialogue: 0,0:01:18.63,0:01:23.68,Default,,0000,0000,0000,,saída do PRF. Ok, em símbolos, temos basicamente o que escrevi aqui. Agora
Dialogue: 0,0:01:23.68,0:01:28.52,Default,,0000,0000,0000,,é simples para mostrar que, de facto, G é um PRG segura, então este bit PRF um é
Dialogue: 0,0:01:28.52,0:01:32.90,Default,,0000,0000,0000,,, de facto, uma PRF seguro. Se você pensar nisso por um segundo, isso realmente não é
Dialogue: 0,0:01:32.90,0:01:37.57,Default,,0000,0000,0000,,[inaudível]. É realmente apenas afirmando a mesma coisa duas vezes. Então eu vou deixá-lo por
Dialogue: 0,0:01:37.57,0:01:42.24,Default,,0000,0000,0000,,você pensar sobre isso de forma breve e ver e se convencer de que de fato esta
Dialogue: 0,0:01:42.24,0:01:46.85,Default,,0000,0000,0000,,teorema é verdadeiro. As verdadeiras questões é se podemos construir um PRF, que na verdade
Dialogue: 0,0:01:46.85,0:01:51.76,Default,,0000,0000,0000,,tem um domínio que é maior do que um bit. Idealmente gostaríamos que o domínio para ser 128
Dialogue: 0,0:01:51.76,0:01:56.42,Default,,0000,0000,0000,,bits, basta dizer que a [inaudível] tem. Então a questão é que podemos construir 128 bits PRS
Dialogue: 0,0:01:56.42,0:02:01.20,Default,,0000,0000,0000,,a partir de um gerador pseudo-aleatório. Bem, então vamos ver se podemos fazer progressos. Assim, o
Dialogue: 0,0:02:01.20,0:02:05.97,Default,,0000,0000,0000,,primeira coisa que vamos fazer é que nós vamos dizer, bem de novo, vamos começar com um PRG
Dialogue: 0,0:02:05.97,0:02:10.86,Default,,0000,0000,0000,,, que duplica o seu contributo vamos ver se podemos construir um PRG que quadruplica suas entradas.
Dialogue: 0,0:02:10.86,0:02:15.80,Default,,0000,0000,0000,,Ok? Assim, ele vai de K para K para o quarto em vez de K para K quadrado. Ok, então vamos
Dialogue: 0,0:02:15.80,0:02:20.81,Default,,0000,0000,0000,,ver como fazer isso. Então, vamos começar com a nossa PRG original que apenas duplica a sua
Dialogue: 0,0:02:20.81,0:02:25.88,Default,,0000,0000,0000,,entradas, agora lembrar que o facto de a sua é um PRG significa que a saída do
Dialogue: 0,0:02:25.88,0:02:30.77,Default,,0000,0000,0000,,PRG é indistinguível de dois valores aleatórios em K. Bem, se a saída se parece
Dialogue: 0,0:02:30.77,0:02:35.85,Default,,0000,0000,0000,,como dois valores aleatórios em K, podemos simplesmente aplicar o gerador de novo para os dois
Dialogue: 0,0:02:35.85,0:02:40.36,Default,,0000,0000,0000,,saídas. Então, digamos que nós aplicamos o gerador de uma vez para a saída da esquerda, e
Dialogue: 0,0:02:40.36,0:02:45.34,Default,,0000,0000,0000,,uma vez para as saídas de direitos. E nós vamos chamar a saída de que, este
Dialogue: 0,0:02:45.34,0:02:50.45,Default,,0000,0000,0000,,quádruplo de elementos, que são, vão chamar isso de G1K. E eu escrevi em
Dialogue: 0,0:02:50.45,0:02:55.55,Default,,0000,0000,0000,,símbolos que esse gerador faz, mas você pode ver, basicamente, a partir desta figura,
Dialogue: 0,0:02:55.55,0:03:00.86,Default,,0000,0000,0000,,exatamente como funciona o gerador. Portanto, agora que temos um gerador de K a K para
Dialogue: 0,0:03:00.86,0:03:06.17,Default,,0000,0000,0000,,quarta, Nós realmente obter um pouco PRF dois. Ou seja, o que vamos fazer é, vamos dizer,
Dialogue: 0,0:03:06.17,0:03:11.41,Default,,0000,0000,0000,,dado dois bits, 000110 ou 11, vontades implica a saída do bloco apropriado que
Dialogue: 0,0:03:11.41,0:03:16.07,Default,,0000,0000,0000,,saída de G1K. Ok, então agora podemos basicamente ter um PRF que leva quatro
Dialogue: 0,0:03:16.07,0:03:21.06,Default,,0000,0000,0000,,entradas possíveis ao invés de apenas duas entradas possíveis como antes. Portanto, a questão
Dialogue: 0,0:03:21.06,0:03:26.11,Default,,0000,0000,0000,,você deve estar me perguntando é porque é que este caso G1 seguro? Por que é um PRG seguro? Que
Dialogue: 0,0:03:26.11,0:03:30.61,Default,,0000,0000,0000,,é por que isso é quadruplicar de saídas indistinguíveis de forma aleatória. E assim
Dialogue: 0,0:03:30.61,0:03:35.66,Default,,0000,0000,0000,,vamos fazer uma prova rápida de isso, apenas vou fazer uma prova simples por imagens. Então aqui está
Dialogue: 0,0:03:35.66,0:03:40.41,Default,,0000,0000,0000,,gerador nossa que queremos provar é seguro. E o que isso significa é que nós
Dialogue: 0,0:03:40.41,0:03:45.40,Default,,0000,0000,0000,,quero argumentar que essa distribuição é indistinguível de um fordable aleatória
Dialogue: 0,0:03:45.40,0:03:49.29,Default,,0000,0000,0000,,em K para a quarta. Ok então nosso objetivo é provar que esses dois são
Dialogue: 0,0:03:49.29,0:03:53.89,Default,,0000,0000,0000,,indistinguíveis. Bem vamos fazer um passo de cada vez. Sabemos que o gerador
Dialogue: 0,0:03:53.89,0:03:58.03,Default,,0000,0000,0000,,é um gerador de segura, portanto, de facto, a saída do primeiro nível é
Dialogue: 0,0:03:58.03,0:04:02.45,Default,,0000,0000,0000,,indistinguível da aleatória. Em outras palavras, se se substituir o primeiro nível por
Dialogue: 0,0:04:02.45,0:04:06.99,Default,,0000,0000,0000,,seqüências verdadeiramente aleatórias estes dois são verdadeiramente aleatórios colhidos na tecla de espaço, então não
Dialogue: 0,0:04:10.27,0:04:11.36,Default,,0000,0000,0000,,adversário eficiente deve ser capaz de distinguir essas duas distribuições. Em
Dialogue: 0,0:04:11.36,0:04:15.95,Default,,0000,0000,0000,,fato, se você pudesse distinguir estas duas distribuições, é fácil mostrar que você
Dialogue: 0,0:04:15.95,0:04:20.77,Default,,0000,0000,0000,,iria quebrar o PRG original. Ok, mas essencialmente você ver que a razão pela qual podemos
Dialogue: 0,0:04:20.77,0:04:25.58,Default,,0000,0000,0000,,fazer esta substituição, pode-se substituir a saída de G, com valores verdadeiramente aleatório, é
Dialogue: 0,0:04:25.58,0:04:30.58,Default,,0000,0000,0000,,exatamente por causa da definição do PRG, que diz que o posto para fora do PRG é
Dialogue: 0,0:04:30.58,0:04:35.39,Default,,0000,0000,0000,,indistinguível de forma aleatória, por isso pode muito bem colocar aleatório lá, e não
Dialogue: 0,0:04:35.39,0:04:40.26,Default,,0000,0000,0000,,adversário eficiente pode distinguir os resultantes duas distribuições. Ok, até agora
Dialogue: 0,0:04:40.26,0:04:45.02,Default,,0000,0000,0000,,tão bom, mas agora podemos fazer a mesma coisa de novo para o lado esquerdo. Em outro
Dialogue: 0,0:04:45.02,0:04:49.71,Default,,0000,0000,0000,,palavras, podemos substituir estes dois pseudo saídas aleatórias, pelas saídas verdadeiramente aleatórios.
Dialogue: 0,0:04:49.71,0:04:53.92,Default,,0000,0000,0000,,E novamente, pois o gerador G é seguro, eficiente nenhum adversário pode dizer
Dialogue: 0,0:04:54.09,0:04:57.81,Default,,0000,0000,0000,,a diferença entre estas duas distribuições. Mas de maneira diferente, se um
Dialogue: 0,0:04:57.81,0:05:02.08,Default,,0000,0000,0000,,adversário pode distinguir estas duas distribuições, então nós também daria uma
Dialogue: 0,0:05:02.08,0:05:06.71,Default,,0000,0000,0000,,ataque ao gerador de G. E agora finalmente nós vamos fazer isso uma última vez. Estamos
Dialogue: 0,0:05:06.71,0:05:11.28,Default,,0000,0000,0000,,vai substituir este par pseudo-aleatório por um par verdadeiramente aleatório, e baixo e eis que
Dialogue: 0,0:05:11.28,0:05:15.67,Default,,0000,0000,0000,,obter a distribuição real de que nós estávamos gravando para, gostaríamos de obter uma distribuição
Dialogue: 0,0:05:15.67,0:05:19.85,Default,,0000,0000,0000,,que é realmente feito de quatro blocos independentes. E agora temos provado isso
Dialogue: 0,0:05:19.85,0:05:23.28,Default,,0000,0000,0000,,transição, basicamente, que estes dois indistinguíveis, estes dois
Dialogue: 0,0:05:23.28,0:05:27.24,Default,,0000,0000,0000,,indistinguíveis, e estes dois indistinguíveis, e, portanto, estes dois
Dialogue: 0,0:05:27.24,0:05:31.48,Default,,0000,0000,0000,,são indistinguíveis, que é o que queríamos provar. Ok então este é o tipo de
Dialogue: 0,0:05:31.48,0:05:35.76,Default,,0000,0000,0000,,a idéia de alto nível para a prova, não é muito difícil fazer este rigoroso,
Dialogue: 0,0:05:35.76,0:05:39.79,Default,,0000,0000,0000,,, mas eu só queria mostrar-lhe a intuição meio de como a prova funciona. Bem,
Dialogue: 0,0:05:39.79,0:05:44.36,Default,,0000,0000,0000,,se fôssemos capazes de estender as saídas de geradores de uma vez, não há nada que impeça
Dialogue: 0,0:05:44.36,0:05:48.82,Default,,0000,0000,0000,,nos de fazê-lo novamente por isso aqui é um gerador G1 que produz quatro elementos em
Dialogue: 0,0:05:48.82,0:05:53.34,Default,,0000,0000,0000,,espaço a chave. E lembre-se a saída aqui é indistinguível do nosso aleatória
Dialogue: 0,0:05:53.34,0:05:57.91,Default,,0000,0000,0000,,par quatro, que é o que acabamos de provar. E então não há nada que nos impede de
Dialogue: 0,0:05:57.91,0:06:02.48,Default,,0000,0000,0000,,aplicando o gerador de novo. Então vamos dar o gerador de aplicá-la a este aleatório
Dialogue: 0,0:06:02.48,0:06:07.22,Default,,0000,0000,0000,,procurando coisa e devemos ser capazes de obter essa coisa aleatória procurando. Este par mais
Dialogue: 0,0:06:07.22,0:06:11.51,Default,,0000,0000,0000,,aqui que é aleatória procurando. E nós podemos fazer a mesma coisa novamente, e novamente, e
Dialogue: 0,0:06:11.51,0:06:16.40,Default,,0000,0000,0000,,novamente. E agora, basicamente, nós construímos um novo gerador que produz elementos em K para
Dialogue: 0,0:06:16.40,0:06:21.26,Default,,0000,0000,0000,,oitavo a, em oposição a K para a quarta. E mais uma vez a prova de segurança é muito
Dialogue: 0,0:06:21.26,0:06:26.06,Default,,0000,0000,0000,,da mesma forma como o que acabei de mostrar, essencialmente, você alterar gradualmente a
Dialogue: 0,0:06:26.06,0:06:30.61,Default,,0000,0000,0000,,saídas em saídas verdadeiramente aleatórios. Então nós mudar isso para um verdadeiramente aleatório
Dialogue: 0,0:06:30.61,0:06:35.17,Default,,0000,0000,0000,,de saída, então este, em seguida, que, em seguida, este, em seguida, que e assim por diante e assim por diante. Até
Dialogue: 0,0:06:35.17,0:06:39.72,Default,,0000,0000,0000,,finalmente temos algo que é verdadeiramente aleatório e, portanto, os dois originais
Dialogue: 0,0:06:39.72,0:06:44.40,Default,,0000,0000,0000,,distribuições nós começamos com G2K e verdadeiramente aleatório são indistinguíveis. Ok,
Dialogue: 0,0:06:44.40,0:06:49.32,Default,,0000,0000,0000,,tão longe tão bom. Portanto, agora temos um gerador que produz elementos em K para o oitavo.
Dialogue: 0,0:06:49.32,0:06:54.02,Default,,0000,0000,0000,,Agora, se fizermos isso, basicamente, temos um bit PRF três. Em outras palavras, a zero, zero,
Dialogue: 0,0:06:54.02,0:06:58.88,Default,,0000,0000,0000,,de zero esta PRF geraria este bloco, e assim por diante e assim por diante, até que um, um, um que
Dialogue: 0,0:06:58.88,0:07:03.16,Default,,0000,0000,0000,,geraria este bloco. Agora, o interessante é que na verdade isso PRF
Dialogue: 0,0:07:03.16,0:07:07.70,Default,,0000,0000,0000,,é fácil de calcular. Por exemplo, vamos supor que queremos para calcular a PRF no ponto
Dialogue: 0,0:07:07.70,0:07:11.95,Default,,0000,0000,0000,,um zero um. Ok, é um pouco PRF três. Ok então um zero um. Como faríamos
Dialogue: 0,0:07:11.95,0:07:16.54,Default,,0000,0000,0000,,que? Bem, basicamente, que iria começar a partir do original chave K. E agora gostaríamos de aplicar
Dialogue: 0,0:07:16.54,0:07:20.62,Default,,0000,0000,0000,,G o gerador, mas nós só prestar atenção ao direito de saída G,
Dialogue: 0,0:07:20.62,0:07:25.04,Default,,0000,0000,0000,,porque o primeiro bit é um. E então vamos aplicar o gerador de novo, mas nós
Dialogue: 0,0:07:25.04,0:07:29.52,Default,,0000,0000,0000,,só prestar atenção para a esquerda da saída do gerador porque o
Dialogue: 0,0:07:29.52,0:07:33.86,Default,,0000,0000,0000,,segundo bit é zero. E, então, se aplicaria o gerador de novo e só paga
Dialogue: 0,0:07:33.86,0:07:38.59,Default,,0000,0000,0000,,atenção para as saídas da direita, porque o terceiro bit é um e que seria o
Dialogue: 0,0:07:38.59,0:07:43.14,Default,,0000,0000,0000,,saída final. Certo, então você pode ver que, que nos levam a 101, e, de fato, porque
Dialogue: 0,0:07:43.14,0:07:47.46,Default,,0000,0000,0000,,gerador [inaudível] é pseudo-aleatório, sabemos que, em particular, que,
Dialogue: 0,0:07:47.46,0:07:52.80,Default,,0000,0000,0000,,esta saída aqui é pseudo-aleatório. Ok, então isso nos dá um pouco PRF três. Bem, se
Dialogue: 0,0:07:52.80,0:07:58.63,Default,,0000,0000,0000,,ele trabalhou três vezes, não há nenhuma razão pela qual não podem trabalhar N vezes. E assim se
Dialogue: 0,0:07:58.63,0:08:03.50,Default,,0000,0000,0000,,aplicar esta transformação mais uma vez, chegamos ao que é chamado de GGMPRF. GGM
Dialogue: 0,0:08:03.50,0:08:07.96,Default,,0000,0000,0000,,estandes para Goldreich, Goldwasser e Micali estes são os inventores do
Dialogue: 0,0:08:07.96,0:08:12.53,Default,,0000,0000,0000,,PRF isso e assim que funciona é o seguinte. Então, começamos com um gerador
Dialogue: 0,0:08:12.53,0:08:17.28,Default,,0000,0000,0000,,apenas dobra suas saídas, e agora nós somos capazes de construir um PRF que atua em um grande
Dialogue: 0,0:08:17.28,0:08:22.24,Default,,0000,0000,0000,,domínio principalmente um domínio de tamanho zero um para o N. ou N poderia ser tão grande como 128 ou mesmo
Dialogue: 0,0:08:22.24,0:08:26.90,Default,,0000,0000,0000,,mais. Então vamos ver, vamos supor que nós estamos dando uma entrada em 01 para o N, deixe-me mostrar-lhe como
Dialogue: 0,0:08:26.90,0:08:31.27,Default,,0000,0000,0000,,para avaliar a PRF. Bem, agora você deve realmente ter uma boa idéia de como
Dialogue: 0,0:08:31.27,0:08:35.48,Default,,0000,0000,0000,,para fazê-lo. Essencialmente, nós começamos a partir da chave original e, em seguida, aplicamos o
Dialogue: 0,0:08:35.48,0:08:40.26,Default,,0000,0000,0000,,gerador e tomamos a esquerda ou a direita dependendo do bit X0 e
Dialogue: 0,0:08:40.26,0:08:44.75,Default,,0000,0000,0000,,, em seguida, chegamos à próxima chave, K1. E, então, aplicar o gerador de novo e nós
Dialogue: 0,0:08:44.75,0:08:49.44,Default,,0000,0000,0000,,tomar à esquerda ou à direita dependendo X1 e chegamos à próxima chave. E
Dialogue: 0,0:08:49.44,0:08:54.73,Default,,0000,0000,0000,,então fazer isso de novo e de novo, até que finalmente estamos a chegar à saída. Então, nós
Dialogue: 0,0:08:54.73,0:08:59.82,Default,,0000,0000,0000,,ter processado todos os bits finais, e chegamos à saída desta função. E
Dialogue: 0,0:08:59.82,0:09:05.17,Default,,0000,0000,0000,,, basicamente, podemos provar a segurança de novo muito bonito ao longo das mesmas linhas como fizemos
Dialogue: 0,0:09:05.17,0:09:10.32,Default,,0000,0000,0000,,antes, e nós podemos mostrar que se G é um PRG seguro, então, de facto, temos um seguro
Dialogue: 0,0:09:10.32,0:09:14.92,Default,,0000,0000,0000,,PRF, a 01 para o N, em um domínio muito grande. Então, isso é fantástico. Agora, temos
Dialogue: 0,0:09:14.92,0:09:19.06,Default,,0000,0000,0000,,temos essencial, temos uma PRF que é comprovadamente seguro, assumindo que o
Dialogue: 0,0:09:19.06,0:09:23.50,Default,,0000,0000,0000,,gerador subjacente é seguro, eo gerador é supostamente muito mais fácil
Dialogue: 0,0:09:23.50,0:09:28.15,Default,,0000,0000,0000,,construir do que um PRF real. E, na verdade ele funciona em blocos que podem ser muito grandes, em
Dialogue: 0,0:09:28.15,0:09:33.30,Default,,0000,0000,0000,,particular, 01 ao 128, que é o que precisávamos. Então você pode perguntar por que não é bem
Dialogue: 0,0:09:33.30,0:09:39.12,Default,,0000,0000,0000,,coisa esta sendo usado na prática? E a razão é, que na verdade é bastante lento.
Dialogue: 0,0:09:39.12,0:09:44.60,Default,,0000,0000,0000,,Então, imagine que ligar como um gerador que conecta o gerador de salsa. Então agora para
Dialogue: 0,0:09:44.60,0:09:50.14,Default,,0000,0000,0000,,avaliar este PRF em um 128 entradas de bits, teríamos basicamente tem que executar o salsa
Dialogue: 0,0:09:50.14,0:09:55.62,Default,,0000,0000,0000,,gerador 128 vezes. Uma vez por bit da entrada. Mas, então, teria um PRF
Dialogue: 0,0:09:55.62,0:10:01.51,Default,,0000,0000,0000,,que é 128 vezes mais lenta do que a salsa original. E isso é muito, muito, muito mais lento
Dialogue: 0,0:10:01.51,0:10:06.23,Default,,0000,0000,0000,,que o AES. AES é um PRF heurística. Mas, no entanto, é muito mais rápido, então o que nós
Dialogue: 0,0:10:06.23,0:10:10.58,Default,,0000,0000,0000,,acabou de chegar aqui. E por isso mesmo que esta é uma construção muito elegante, ela não é usada
Dialogue: 0,0:10:10.58,0:10:14.52,Default,,0000,0000,0000,,, na prática, para construir pseudo funções aleatórias, embora em uma semana estaremos
Dialogue: 0,0:10:14.52,0:10:18.92,Default,,0000,0000,0000,,usando este tipo de construção para construir um mecanismo de integridade da mensagem. Assim, a última
Dialogue: 0,0:10:18.92,0:10:23.18,Default,,0000,0000,0000,,passo, é basicamente agora que temos construído um PRF, as perguntas é se podemos
Dialogue: 0,0:10:23.18,0:10:27.73,Default,,0000,0000,0000,,realmente construir a cifra de bloco. Em outras palavras, podemos realmente construir uma PRP seguro
Dialogue: 0,0:10:27.73,0:10:32.05,Default,,0000,0000,0000,,a partir de um PRG seguro. Tudo o que fizemos até agora, não é reversível. Novamente, se você
Dialogue: 0,0:10:32.05,0:10:36.60,Default,,0000,0000,0000,,olhar para essa construção aqui, não podemos decifrar, basicamente devido aos resultados finais.
Dialogue: 0,0:10:36.60,0:10:40.54,Default,,0000,0000,0000,,Não é possível voltar atrás ou, pelo menos, não sabemos como voltar a, o
Dialogue: 0,0:10:40.54,0:10:44.52,Default,,0000,0000,0000,,entradas originais. Então agora a questão de interesse é tão podemos realmente resolver o
Dialogue: 0,0:10:44.52,0:10:48.65,Default,,0000,0000,0000,,problema que queria resolver inicialmente? Principalmente, podemos realmente construir uma cifra de bloco de
Dialogue: 0,0:10:48.65,0:10:53.54,Default,,0000,0000,0000,,um PRG seguro? Tão mal deixá-lo pensar sobre isso por um segundo, e marcar a resposta. Assim
Dialogue: 0,0:10:53.54,0:10:57.72,Default,,0000,0000,0000,,é claro que eu espero que todos disse que a resposta é sim e você já tem todos os
Dialogue: 0,0:10:57.72,0:11:01.90,Default,,0000,0000,0000,,ingredientes para fazê-lo. Em particular, você já sabe como construir um PRF de um
Dialogue: 0,0:11:01.90,0:11:06.40,Default,,0000,0000,0000,,gerador pseudo-aleatório. E nós dissemos que uma vez que temos um PRF que podemos ligá-lo na
Dialogue: 0,0:11:06.40,0:11:10.57,Default,,0000,0000,0000,,construção Luby-Rackoff, que se você se lembra, é apenas Feistel um três-redonda.
Dialogue: 0,0:11:10.57,0:11:14.75,Default,,0000,0000,0000,,Então nós dissemos que se você ligar um PRF seguro em um Feistel de três rounds, você recebe um
Dialogue: 0,0:11:14.75,0:11:19.04,Default,,0000,0000,0000,,PRP seguro. Então, combinando estes dois, basicamente nos dá uma PRP seguro
Dialogue: 0,0:11:19.04,0:11:23.33,Default,,0000,0000,0000,,a partir de um gerador pseudo-aleatório. E isto é provably assegurar enquanto o
Dialogue: 0,0:11:23.33,0:11:28.08,Default,,0000,0000,0000,,gerador subjacente é segura. Portanto, é um belo resultado, mas infelizmente mais uma vez
Dialogue: 0,0:11:28.08,0:11:32.48,Default,,0000,0000,0000,,ela não é usada na prática porque é consideravelmente mais lento que a heurística
Dialogue: 0,0:11:32.48,0:11:36.72,Default,,0000,0000,0000,,construções como AES. Ok assim que este completa o nosso módulo sobre construção
Dialogue: 0,0:11:36.72,0:11:40.46,Default,,0000,0000,0000,,pseudo permutações aleatórias e pseudo funções aleatórias. E, em seguida, no próximo
Dialogue: 0,0:11:40.46,0:11:44.29,Default,,0000,0000,0000,,módulo nós vamos falar sobre como usar essas coisas para fazer a criptografia apropriada.