2023年8月16日水曜日

RustでDLL(2)

 
WSLでRustでWindowsで動くソフトができたってなるとDLLも作ってみたくなるじゃんね。

酒飲んでメンタル復調したので続きをする。 

  1. const S:[[u8;16];16]=[
  2.     [0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76],
  3.     [0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0],
  4.     [0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15],
  5.     [0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75],
  6.     [0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84],
  7.     [0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf],
  8.     [0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8],
  9.     [0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2],
  10.     [0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73],
  11.     [0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb],
  12.     [0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79],
  13.     [0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08],
  14.     [0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a],
  15.     [0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e],
  16.     [0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf],
  17.     [0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16] 
  18. ];
  19. const INVS:[[u8;16];16]=[
  20.     [0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38,0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb],
  21.     [0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87,0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb],
  22.     [0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d,0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e],
  23.     [0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2,0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25],
  24.     [0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16,0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92],
  25.     [0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda,0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84],
  26.     [0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a,0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06],
  27.     [0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02,0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b],
  28.     [0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea,0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73],
  29.     [0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85,0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e],
  30.     [0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89,0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b],
  31.     [0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20,0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4],
  32.     [0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31,0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f],
  33.     [0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d,0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef],
  34.     [0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0,0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61],
  35.     [0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26,0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d]
  36. ];
  37. static mut W:[[u8;16];11]=[[0;16];11];
  38. const RCON:[u8;10]=[0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36];
  39.  
  40. fn subword(indata:&mut [u8]){
  41.     for i in 0..16{
  42.         indata[i]=S[((indata[i]>>4)&0x0F) as usize][((indata[i]>>0)&0x0F) as usize];
  43.     }
  44. }
  45. fn rotword(indata:&mut [u8]){
  46.     let tmp:u8=indata[0];
  47.     indata[0]=indata[1];
  48.     indata[1]=indata[2];
  49.     indata[2]=indata[3];
  50.     indata[3]=tmp;
  51. }
  52. fn keyexpansion_single(num:u8){
  53.     unsafe{
  54.         for i in 0..4{
  55.             W[num as usize][i]=W[(num-1) as usize][12+i];
  56.         }
  57.         rotword(&mut W[num as usize][0..4]);
  58.         subword(&mut W[num as usize][0..16]);
  59.         W[num as usize][0]^=RCON[(num-1) as usize];
  60.         for i in 0..4{
  61.             W[num as usize][i]^=W[(num-1) as usize][i];
  62.             W[num as usize][i+4]=W[num as usize][i]^W[(num-1) as usize][i+4];
  63.             W[num as usize][i+8]=W[num as usize][i+4]^W[(num-1) as usize][i+8];
  64.             W[num as usize][i+12]=W[num as usize][i+8]^W[(num-1) as usize][i+12];
  65.         }
  66.     }
  67. }
  68. fn keyexpansion(key:&[u8]){
  69.     for i in 0..16{
  70.         unsafe{
  71.             W[0][i]=key[i];
  72.         }
  73.     }
  74.     for i in 1..11{
  75.         keyexpansion_single(i);
  76.     }
  77. }
  78. fn addroundkey(src:&mut [u8],nround:u8){
  79.     for i in 0..16{
  80.         unsafe{
  81.             src[i]^=W[nround as usize][i];
  82.         }
  83.     }
  84. }
  85. fn subbytes(src:&mut [u8]){
  86.     for i in 0..16{
  87.         src[i]=S[((src[i]>>4)&0x0F) as usize][((src[i]>>0)&0x0F) as usize];
  88.     }
  89. }
  90. fn invsubbytes(src:&mut [u8]){
  91.     for i in 0..16{
  92.         src[i]=INVS[((src[i]>>4)&0x0F) as usize][((src[i]>>0)&0x0F) as usize];
  93.     }
  94. }
  95. fn shiftrows(src:&mut [u8]){
  96.     let mut temp:[u8;8]=[0;8];
  97.     for i in 0..4{
  98.         for j in 0..4{
  99.             temp[j]=src[j*4+i];
  100.             temp[j+4]=src[j*4+i];
  101.         }
  102.         for j in 0..4{
  103.             src[j*4+i]=temp[j+i];
  104.         }
  105.     }
  106. }
  107. fn invshiftrows(src:&mut [u8]){
  108.     let mut temp:[u8;8]=[0;8];
  109.     for i in 0..4{
  110.         for j in 0..4{
  111.             temp[j]=src[j*4+i];
  112.             temp[j+4]=src[j*4+i];
  113.         }
  114.         for j in 0..4{
  115.             src[j*4+i]=temp[j+4-i];
  116.         }
  117.     }
  118. }
  119. fn mul(a:u8,b:u8)->u8{
  120.     let mut x:u8=0;
  121.     let isrc:[u8;4]=[8,4,2,1];
  122.     for i in isrc.iter(){
  123.         if (x&0x80)>0 {
  124.             x<<=1;
  125.             x^=0x1b;
  126.         }else{
  127.             x<<=1;
  128.         }
  129.         if (b&i)>0 {
  130.             x^=a;
  131.         }
  132.     }
  133.     return x;
  134. }
  135. fn mixcolumn_single(r:&mut [u8]){
  136.     let mut t:[u8;4]=[0;4];
  137.     for i in 0..4{
  138.         t[i]=r[i];
  139.     }
  140.     r[0]=mul(t[0],2)^mul(t[1],3)^mul(t[2],1)^mul(t[3],1);
  141.     r[1]=mul(t[1],2)^mul(t[2],3)^mul(t[3],1)^mul(t[0],1);
  142.     r[2]=mul(t[2],2)^mul(t[3],3)^mul(t[0],1)^mul(t[1],1);
  143.     r[3]=mul(t[3],2)^mul(t[0],3)^mul(t[1],1)^mul(t[2],1);
  144. }
  145. fn mixcolumns(src:&mut [u8]){
  146.     for i in 0..4{
  147.         mixcolumn_single(&mut src[(i*4)..(i*4+4)]);
  148.     }
  149. }
  150. fn invmixcolumn_single(r:&mut [u8]){
  151.     let mut t:[u8;4]=[0;4];
  152.     for i in 0..4{
  153.         t[i]=r[i];
  154.     }
  155.     r[0]=mul(t[0],14)^mul(t[1],11)^mul(t[2],13)^mul(t[3],9);
  156.     r[1]=mul(t[1],14)^mul(t[2],11)^mul(t[3],13)^mul(t[0],9);
  157.     r[2]=mul(t[2],14)^mul(t[3],11)^mul(t[0],13)^mul(t[1],9);
  158.     r[3]=mul(t[3],14)^mul(t[0],11)^mul(t[1],13)^mul(t[2],9);
  159. }
  160. fn invmixcolumns(src:&mut [u8]){
  161.     for i in 0..4{
  162.         invmixcolumn_single(&mut src[(i*4)..(i*4+4)]);
  163.     }
  164. }
  165.  
  166. fn cipher(data:&mut [u8]){
  167.     addroundkey(data,0);
  168.     for i in 1..10{
  169.         subbytes(data);
  170.         shiftrows(data);
  171.         mixcolumns(data);
  172.         addroundkey(data,i);
  173.     }
  174.     subbytes(data);
  175.     shiftrows(data);
  176.     addroundkey(data,10);
  177. }
  178. fn invcipher(data:&mut [u8]){
  179.     addroundkey(data,10);
  180.     for i in 1..10{
  181.         invshiftrows(data);
  182.         invsubbytes(data);
  183.         addroundkey(data,10-i);
  184.         invmixcolumns(data);
  185.     }
  186.     invshiftrows(data);
  187.     invsubbytes(data);
  188.     addroundkey(data,0);
  189. }
  190. #[no_mangle] pub extern "C" fn AES128Encrypt(plain:&[u8;16],key:&[u8;16],enc:&mut [u8;16]){
  191.     for i in 0..16{
  192.         enc[i]=plain[i];
  193.     }
  194.     keyexpansion(key);
  195.     cipher(enc);
  196. }
  197. #[no_mangle] pub extern "C" fn AES128Decrypt(enc:&[u8;16],key:&[u8;16],invenc:&mut [u8;16]){
  198.     for i in 0..16{
  199.         invenc[i]=enc[i];
  200.     }
  201.     keyexpansion(key);
  202.     invcipher(invenc);
  203. }
  204.  
  205. #[cfg(test)]
  206. mod tests{
  207.     use super::*;
  208.     #[test]
  209.     fn vmain() {
  210.         let key:[u8;16]=[0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f];
  211.         let plain:[u8;16]=[0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff];
  212.         let mut dataf:[u8;16]=[0;16];
  213.         let mut datab:[u8;16]=[0;16];
  214.         print!("KEY     :");
  215.         for i in 0..16{
  216.             print!("{:02X}",key[i]);
  217.         }
  218.         println!("");
  219.         print!("PLAIN   :");
  220.         for i in 0..16{
  221.             print!("{:02X}",plain[i]);
  222.         }
  223.         println!("");
  224.         AES128Encrypt(plain,key,dataf);
  225.         print!("CHIPHRED:");
  226.         for i in 0..16{
  227.             print!("{:02X}",dataf[i]);
  228.         }
  229.         println!("");
  230.         AES128Decrypt(dataf,key,datab);
  231.         print!("PLAIN   :");
  232.         for i in 0..16{
  233.             print!("{:02X}",datab[i]);
  234.         }
  235.         println!("");
  236.     }
  237. }

いきなり、こちらのコードとなります。

新しく追加した関数、

AES128Encrypt

AES128Decrypt

について、

#[no_mangle] pub extern "C" 

を付けるのは前回やったけど、これまでのRustの知識で行くと

#[no_mangle] pub extern "C" fn AES128Encrypt(plain:&[u8],key:&[u8],enc:&mut [u8]){

...

}

#[no_mangle] pub extern "C" fn AES128Decrypt(enc:&[u8],key:&[u8],invenc:&mut [u8]){

...

}

って書いちゃうわけで、そすと、

って感じで、めっちゃ怒られて超絶凹む。

で、市の図書館に行ってRustの本を読んでみた。やっぱ本になっていると見やすいよねー。web情報ほじくり倒したけど、いまいち頭に入ってこないわけだよ初老の中年の頭には。で、関数の引数にサイズまで含んでいると配列と認識されて、サイズが含まれていないとスライスと認識されることが判明した。なので、C言語から(extern "C"なので)スライスはでけんよって警告になっているらしい。なので、

#[no_mangle] pub extern "C" fn AES128Encrypt(plain:&[u8;16],key:&[u8;16],enc:&mut [u8;16]){

...

}

#[no_mangle] pub extern "C" fn AES128Decrypt(enc:&[u8;16],key:&[u8;16],invenc:&mut [u8;16]){

...

}

ってする。で、

と、うまく逝った感じになる。

では、実行してみる。ちょっと前にC#でやったので、それを使う。が再びゼロからやってみる。

フォルダを作ってC#のプロジェクトを作ってVSCodeを起動する。

(ところでC#の開発環境ってBuildToolsとか入れなくても最初っからWindowsに入っているらしい、、、早く言ってよーー)

プロジェクトのフォルダに作成したdllをコピペして、呼び出すライブラリ名を変える。ちなみにプロトタイプ(関数名やら引数やら)は同じなので、変更不要。

dotnet run --project

ってやったらめたくそ怒られた。前回は動いたのにーで、

dotnet run

でうまくいった。

ちゃんと動いているーーこれぞ「燃える闘魂」

が、しかし、、、ホント、やらんといかんことが多すぎてどれもやる気がしない、やりたいことが多すぎてどれにも手が付けられないんだよねー。老いて心の燃料がなくなってきた気がする。可燃性、不燃性、自燃性いずれにしても燃料がないと、、、

at 0 件のコメント:
Labels:

2023年8月15日火曜日

RustでDLL(1)

WSLでRustでWindowsで動くバイナリが作れるとなるとDLLも作ってみたくなるのが人間の性ってやつだと思うわけです。参考サイトはこちら。今回も先人のたどった道をなぞる。猿真似？いや「学而時習之。不亦説乎。」ですよ。

 

まずはlib用のプロジェクトを作る。どんな感じなのかヘルプで調べる

cargo help new

で

cargo new --lib なんたら

ってすればいいらしい。

で、こうして、(今回も例題としてaes128を使うつもりなので、名前がrijndael)

こうなる。exampleとしてaddって関数を作ってくれている。が、これだと公開してくれないらしい。C++で作るときと一緒でextern "C"が必要だったり、マングリング防止のおまじないが必要だったりするらしい。

こうする。で、

前回に倣ってプロジェクトフォルダ内に.cargoフォルダを作って、その中にconfigってファイルを作って、

まぁ、こうする。

で、今回はここだけじゃなくて、Cargo.tomlも編集するらしい。

[lib]

crate-type = ["cdylib"]

を追加する。

で、

cargo build --lib --target x86_64-pc-windows-gnu

で、できたと言っている。

それらしいのがある。これを、WSLのフォルダからWindowsのフォルダに持ち込んで、Dependenciesで確認すると、

とりあえず、できているっぽい。

 

、、、しんどいので一度中断する。

at 0 件のコメント:
Labels:
登録: 投稿 (Atom)