Let's take a break and talk a bit about computer security--
a topic we really haven't touched on much in this unit so far.
Security can sometimes be defined as computing in the presence of an adversary--
someone else using a computer or a network or resources
who means you hard or hopes to exploit or take advantage of resources
resources that you've put out there.
It just so happens--you'll be surprised to discover I am breaking this news--
that the internet is not secure.
Malicious agents or adversaries can write malicious webpages or JavaScript fragments.
The simplest way to do this would be to write a JavaScript fragment that loops forever--
some sort of version of Fibonacci that has no stopping condition
that just keeps going and going and going.
Then as soon as you've directed your browser to that page, it would stall,
and you'd be denied some server. You wouldn't be able to use your computer.
In practice, browsers often put some sort of timeout on script execution.
I'll run your script for 3 or 4 seconds, and after that if it hasn't finished, I'd better stop.
that's one of the reasons why optimization is so important, but it also has this security angle.
If we make any mistakes when we're designing our web browser,
then outside agents might break in to our computers and gain access
to sensitive documents--our tax returns, our personal email, or whatnot.
We want to make sure that that doesn't happen.
Let's listen to someone who knows quite a bit more about security than I do
talk about how this plays out in the real world with web browsers.
The web can be a great place but it can also be a dangerous place.
Nothing stops users from posting malicious code or websites
or writing scripts that will trying to take advantage of your computer or your browser.
There might be security holes or exploits, they're sometimes called, that allow this.
I was wondering if you might talk a bit about security at the language or implementation level
from the perspective of Mozilla.
Absolutely. Security is a prevalent concern at Mozilla.
When I was growing up, the idea of getting a piece of software was that you actually
drove to a store and you looked at a shelf and you pulled a box off the shelf
and you paid somebody and you took it home and that piece of software was sold to you
by a company that you trusted, by a third party that you trusted,
so you had some sense of this piece of software that I'm about to put on my computer
is something that I can believe is going to do something on behalf,
not something against me.
The web doesn't work like that way at all.
The way web applications work is you can go to any website anywhere in the world,
and somebody you've never met and never seen and that nobody can vouch for you
is going to run some of their code that they wrote on your computer.
So that changes the game.
That means that in order to build a serious platform where programs can do important things
on your behalf, we need to make sure that they can't also do important things against you.
The more people put valuable parts of their lives onto the web like their bank account,
for example, the more we have important assets to defend.
One of the concepts people talk about a lot in security is the notion of the trust computing base.
When you download some code from some third party that you don't know,
if we're being kind of maximally pessimistic we say, well, I don't trust this code completely.
I'd like it to do something for me but I don't know for sure that it's not malicious.
However, that code is running inside of a web browser like Firefox,
and I do trust the code that was written by Mozilla. I do trust Firefox.
In order to be able to say as much as we can about the security of a system,
we'd like for the parts of the system that we need to trust the most
to be as small as possible, so we talk about shrinking the trusted computing base,
as being a goal of having the smallest possible amount of software where if it goes wrong
disaster can ensue--like somebody can steal or credit card information or your bank account.
All modern web browsers are implemented in C++.
Now, C++ is a very powerful language. There are a lot of things that you can do with it.
But it's also not a particularly safe language.
It's a language where if you make one wrong move, if you make one little programming mistake,
you can actually leave parts of your system open to malicious programs.
For example, if you write a program in C++ and you have an array of data
and you forget to make sure that the program doesn't go beyond the end of that array,
in most programming languages you'll get a runtime error that says,
"Oops. You tried to access beyond the end of the array."
C++ doesn't give you that protection.
What C++ does is it just keeps reading what ever happens to be in memory
at the end of that array.
Well, whatever happens to be in memory could actually be some part of the browser
that has internal information like a password.
It could also be some other program running on the system,
and there are a lot of people out there who work on finding ways to exploit
these kinds of bugs to use them to take control of your computer or to get access to your private data.
The project of building a web browser that people can trust
and building a web browser that operates on user's behalf
is also one of building software that they can trust.
In order to build software that they can trust,
it needs to be built on top of programming technologies
that we know we can work with effectively to build software that's not unsafe.
We've been discussing malicious code like JavaScript written by evildoers
that we would run in our interpreter. Running evil code seems really bad.
Can't I just look at the source code and tell if it's bad before I run it
and then not run the bad code? Why doesn't Mozilla do something like that.
Unfortunately, it turns out that there's a lot of good theoretical computer science
that shows us that that is a provably impossible problem.
I don't know if you've discussed the halting program. >>We may have.
It turns out that if I were able to prove that any particular piece of code was not malicious
I would also be able to solve the halting problem,
and we already know that that's an unsolvable problem in computer science.
Looking at this maybe from a more positive side,
that means that I'll always have a job.
The law of compiler writer employability. >>Exactly.
休憩してコンピュータの セキュリティについて話しましょう
これまであまり触れてこなかった話題です
セキュリティは敵対的な存在がいる時に 行う処理であると言えます
他の人がコンピュータやネットワークなどの資源を
使おうとしているのを退けて 自分が資源を使うことです
驚くかもしれませんが インターネットはセキュアではありません
悪意のある人が悪意のあるWebページや JavaScriptを書くことができます
一番簡単な方法は永遠にループする JavaScriptを書くことです
停止条件がないフィボナッチを求める 関数を書けば
ただずっと続きます
そのページを開くとブラウザが停止します
サーバから切断され コンピュータを使えなくなるかもしれません
実際にはブラウザはスクリプトの実行に 時間制限を設けています
3、4秒はスクリプトを実行しますが それでも終わっていない場合は停止させます
最適化が重要な理由の1つですが セキュリティの観点からの施策です
Webブラウザを設計する時にミスをすると
外部の人が個人的なメールや重要な書類に アクセスできるようになるかもしれません
そういうことが起こらないようにしたいのです
セキュリティに詳しい人から 現実のWebブラウザについて聞いてみます
Webはすばらしい場所であると同時に 危険な場所でもあります
悪意のあるコードやWebサイトを作り
コンピュータやブラウザへの乗っ取りを 止めるものは何もありません
セキュリティホールやエキスプロイトを突く コードもあるかもしれません
言語の実装面においてMozillaから見た セキュリティについて話を伺えますか？
もちろんです セキュリティは Mozillaでも大いに関心を持っています
私がまだ子どもだった頃 ソフトウェアを入手するというのは
店に行って棚を見て箱を取って お金を払って家に持ち帰ることでした
信頼できる会社や第三者から ソフトウェアを買っていたので
そのソフトウェアは私のコンピュータに 私の代わりに何かをしてくれるのであって
攻撃するものではないと信じていました
Webではそのようにいきません
Webアプリケーションでは 世界のいかなるWebサイトへも行き
会ったことのない人の誰も保証しないコードを 自分のコンピュータで実行していくことになります
世界が変わりました
厳重なプラットフォームを作りプログラムが 私の代わりに何か重要なことをする時に
それが自分の利益に反しないことを 確かめなければなりません
銀行の口座などの重要な情報を載せるにつれて 守るべき重要なものが増えていきます
セキュリティについて一番語られているのは 信頼できる処理基盤です
知らない第三者から コードをダウンロードしたとします
悲観的に考えるとすると そのコードは完全に信用ならないことになります
何かをしてくれるかもしれませんが 悪意がないかどうか分かりません
しかしそれはFirefoxのような Webブラウザの中で実行されます
Mozillaで書かれたコードで 私はFirefoxを信用しています
システムのセキュリティについて言えることは
信用するシステムの一部をできるだけ小さくして つまり信用できる処理基盤を小さくして
重要な情報を盗まれるような悲劇を 起こす可能性のあるソフトウェアを
できるだけ小さくすることが必要だということです
現代のWebブラウザは すべてC＋＋言語で実装されています
C＋＋言語はとても強力な言語で 多くのことができます
しかし特に安全な言語というわけではありません
プログラミングでミスをすればシステムを 悪意のあるプログラムにさらすことにもなります
たとえばC＋＋言語でデータの配列を持ち プログラムが配列の終わりの指定を忘れたとします
多くのプログラミング言語では ランタイムエラーが起きて
配列の終わりを越えてアクセスしようとしたことを 教えてくれます
C＋＋言語にはこのような安全装置がありません
C＋＋言語はただ配列の終わりのあとの メモリにあるものを読み続けます
メモリにあるものはブラウザの別の部分や パスワードといった内部的な情報かもしれません
システムで走る別のプログラムかもしれません
世界には多くの人々が そのようなバグによる穴を見つけて
他の人のコンピュータを乗っ取り 個人的なデータにアクセスしようとしています
人々が信頼できるWebブラウザを作ることと
ユーザのために動作するWebブラウザを作ることは
ユーザが信頼できるソフトウェアを作ることです
そのためにはプログラミング技術をよく知り 効果的に安全なプログラムを作ることが必要です
講義でもJavaScriptの悪意のあるコードが
私たちのインタプリタで実行され得ると話しました
ソースコードを見て実行する前に悪いコードか どうかを判断して実行を制御できないでしょうか？
Mozillaではそのようなことはしないのですか？
残念ながらコンピュータ・サイエンスの定理で それは不可能だということが証明されています
停止性問題については教えましたか？
はい 教えました
もしどんなコードも悪意がないと証明できれば
停止性問題も解けたことになってしまいます
しかしそれはコンピュータ・サイエンスでは 不可能であると示されています
明るい面を言うと 私の仕事はなくならないということになります
ちょうどコンパイラ製作者の 雇用不滅の法則と同じですね
確かに
Vamos dar uma parada e falar um pouco sobre segurança de computadores --
um tópico em que realmente não tocamos muito nesta unidade, até agora.
Segurança pode ser algumas vezes definida como computação na presença de uma adversário --
alguém usando um computador, ou uma rede, ou recursos --
que frustra suas expectativas de usar, ou se aproveita, de
recursos que você tem disponíveis.
Isso acontece -- você poderá ficar surpreso em descobrir. Eu estou avisando:
a internet não é segura.
Agentes maliciosos, ou adversários, podem escrever páginas web ou fragmentos de JavaScript maliciosos.
A maneira mais simples de fazer isso seria escrever um fragmento JavaScritp que fica em loop indefinidamente --
algum tipo de versão de Fibonacci que não tenha a condição de parada,
que simplesmente continua computando e computando.
Então, desde que você direcione seu browser para essa página, ela travaria.
E voc6e culparia algum servidor. Você não poderia usar seu computador.
Na prática, browsers frequentemente usam algum tipo de limeite de tempo para execução de um script:
eu executo o script por 3 ou 4 segundos e, depois disso, se ele não teiver terminado, é melhor eu interrompê-lo.
Essa é uma das razões porque otimização é tão importantes, mas tem também esse aspecto de segurança.
Se eu cometer erros quando estiver projetando nosso web browser,
agentes externos poderão invadir nossos computadores e obter acesso
a documentos importantes: nossos pagamentos, nosso email pessoal ou o que quer que seja.
Queremos nos certificar de que isso não acontecerá.
Vamos ouvir alguém, que entende muito mais sobre segurança do que eu,
falar sobre como isso acontece no mundo real, com web browsers.
A página web pode ser um ótimo lugar, mas pode também ser um lugar perigoso.
Nada impede os usuários de postar código ou ou páginas web maliciosos,
ou de escrever script que irão tentar tirar ventagem do seu computador ou do seu web browser.
Podem haver furos de segurança, ou buracos -- como são às vezes chamados -- que possibilitem isso.
Eu gostaria de saber se você poderia falar um pouco sobe segurança no nível de linguagem, ou no nível de implementação,
da perspectiva da Mozilla.
Certamente. Segurança é uma preocupaçào constante na Mozilla.
Quando eu era mais novo, a idéia de comprar algum software era que você realmente
fosse a uma loja, olhasse nas prateleiras e pegasse uma caixa da preteleira,
pagasse a alguém e a levasse para casa. E esse software era vendido a você
por uma empresa na qual você confiava, um terceiro em que você confiava.
Então, você sentia que esse software, que você estava prestes a instalar no seu computador,
era algo que se podia acreditar que faria algo em seu favor,
e não contra você.
A web não funciona assim, de jeito nenhum.
A maneira como aplicações web funcionam é que voc6e pode ir a qualquer website, em qualquer lugar do mundo,
e alguém que voc6e nunca encontrou e nunca viu, e que ninguém pode fiar para você,
irá executar algum código que ela escreveu, em seu computador.
Então, isso muda o jogo.
Isso significa que, para construir uma plataforma séria, em que programas possam fazer coisas importantes,
em seu favor, precisamos garantir que eles não possam, também, fazer coisas que te tragam prejuízo.
Quanto mais as pessoas colocam parte valiosa da suas vidas na web, como sua conta bancária,
por exemplo, mais nós temos que ter recursos para nos defender.
Um dos conceitos sobre o qual as pessoas falam muito em segurança é a noção de base de computação confiável.
Quando você tem que baixar algum código de um terceiro, que você não conhece,
se formos extremamente pessimistas, diremos: 'eu não confio neste código completamente;
eu gostaria que ele fizesse algo útil para mim, mas eu não tenho certeza se ele não é malicioso'.
Entretanto, esse código está executando dentro de um web browser, tal como Firefox,
e eu acredito no codigo que foi escrito pela Mozilla. Eu acredito no Firefox.
Para poder garantir tanto quanto pudermos a segurança de um sistema,
gostaríamos que as partes so sistema em que precisamos confiar mais
sejam tão pequenas quanto possível. Então, estamos falando de restringir a base computacional confiável,
como sendo o objetivo de ter a menor quantidade de software em que, se algo der errado,
isso possa ser desatroso -- como alguém poder roubar informação sobre seu cartào de crédito ou sua conta bancária.
Todos os web browsers modernos são implementados em C++.
C++ é uma linguagem muito poderosa. existem muitas coisas que se pode fazer com ela.
Mas é também uma linguagem não muito segura.
É uma linguagem em que, se você faz algum movimento errado, se você comete algum pequeno erro em um programa,
você pode realmente deixar partes do seu sistema abertas a programas maliciosos.
Por exemplo, se você escreve um programa C++ e você tem um array de dados,
e você se esquece de garantir que o programa não faça referência fora dos limites do array,
na maioria das linguagens, você irá obter um erro de execução que diz:
"Oops! Você tentou acessas além dos limites do array."
C++ não te dá essa proteção.
O que C++ faz é simplesmente continuar lendo o que quer que esteja na memória,
depois do final do array.
Bem, o que quer que esteja na memória pode ser, de fato, alguma parte do browser
que tenha informação interna, tal como uma senha de acesso.
Pode também ser algum outro programa que esteja executando no sistema.
E existem muitas pessoas trabalhando para encontrar maneiras de explorar
esse tipo de defeitos, para usá-los para tomar controle so seu computador ou para ter acesso a seus dados privados.
O projeto de construir um web browser em que as passoas possam confiar,
de construir um web browser que opere em favos do usuário,
é também aquele de construir software no qual possamos confiar.
Para construir software no qual se possa confiar,
é necessário nos basearmos em tecnologias de topo,
que sabemos que possam ser efetivas para auxiliar a construir software que não seja inseguro.
Temos discutido código malicioso, como JavaScript escrito por malfeitores,
que poderiam ser executados em nosso interpretador. Executar código malicioso parece ser muito ruim.
>> Não podemos simplesmente olhar para um código fonte e dzer se ele é ou não ruim, antes de executá-lo,
e então decidir não executar o código ruim? Porque Mozilla não faz algo como isso?
Infelizmente, acontece que existe uma sólida teoria da computação
que mostra que se pode provar que este é um problema impossível.
Eu não sei se você discutiu o problema da parada. >>Nós discutimos sim.
Acontece que, se eu fosse capaz de provar que uma parte de código arbitrária não é maliciosa,
eu poderia provar que sou capaz de resolver o problema da parada.
E já sabemos que este é um problema inslúvel em ciênica da computação.
Vendo isso por um lado talvez mais positivo,
Isso significa que nós sempre teremos emprego:
é a lei da empregabilidade do escritor de compilador. >>Exatamente.