GhidrOllama
1.0.0
สคริปต์ Ghidra การโต้ตอบของ Ollama API สำหรับวิศวกรรมย้อนกลับที่ได้รับความช่วยเหลือจาก LLM
สคริปต์นี้โต้ตอบกับ API ของ Ollama เพื่อโต้ตอบกับ Large Language Models (LLM) ใช้ Ollama API เพื่อทำงานวิศวกรรมย้อนกลับต่างๆ โดยไม่ต้องออกจาก Ghidra รองรับอินสแตนซ์ Ollama ทั้งในพื้นที่และระยะไกล สคริปต์นี้ได้รับแรงบันดาลใจจาก GptHidra
สคริปต์นี้รองรับโมเดลใดๆ ที่ Ollama รองรับ
นอกจากนี้ Ollama ยังเพิ่มการรองรับโมเดลใดๆ ก็ตามที่มีบน HuggingFace ในรูปแบบ GGUF เช่น:
ollama run hf.co/arcee-ai/SuperNova-Medius-GGUF
คุณสามารถแทนที่ llama3.1:8b ด้วยโมเดลที่เข้ากันได้กับ Ollama ได้ตามใจชอบ
curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.1:8b
ตอนนี้คุณน่าจะพร้อมแล้ว localhost:11434 ควรพร้อมที่จะจัดการกับคำขอ
หมายเหตุ: สคริปต์นี้ยังรองรับอินสแตนซ์ระยะไกล ตั้งค่าที่อยู่ IP และพอร์ตระหว่างการกำหนดค่าครั้งแรก
มีตัวเลือกการกำหนดค่าต่อไปนี้ให้ใช้งานได้ และสามารถกำหนดค่าได้เมื่อเรียกใช้ครั้งแรก:
localhost11434http หรือ https ขึ้นอยู่กับการกำหนดค่าอินสแตนซ์ของคุณสามารถใช้ตัวเลือก 11 และ 12 เพื่อปรับการตั้งค่าหลังจากการเรียกใช้ครั้งแรก
~/ghidra_scripts )การเข้าไปในหน้าต่างสคริปต์เพื่อเรียกใช้สคริปต์นี้ทุกครั้งไม่สะดวกสามารถเรียกใช้สคริปต์ได้อย่างง่ายดายด้วยวิธีดังต่อไปนี้:
หากต้องการเปิดใช้งาน เมื่อคุณเพิ่มสคริปต์ของคุณลงในรายการไดเร็กทอรีสคริปต์ Ghidra แล้ว ให้ค้นหาสคริปต์ในรายการ คลิกขวาที่ผลลัพธ์ และเลือก "กำหนดการเชื่อมโยงคีย์" หากระบบแจ้งให้ใส่รหัส ให้ป้อน q
หากต้องการเปิดใช้งานไอคอนแถบเครื่องมือ ให้ค้นหาสคริปต์ในตัวจัดการสคริปต์ แล้วคลิกกล่องกาเครื่องหมายในคอลัมน์แรก (คอลัมน์ ในแถบเครื่องมือ ) ไอคอน GhidrOllama ควรปรากฏในแถบเครื่องมือ
ด้านล่างนี้คือการใช้งาน strchr() ดังที่เห็นในหน้าต่างถอดรหัส Ghidra ที่มีสัญลักษณ์ที่ถูกถอดออก:
char * FUN_801a7490 ( char * param_1 , char param_2 )
{
char cVar1 ;
char * pcVar2 ;
cVar1 = * param_1 ;
if ( cVar1 == ' ' ) {
pcVar2 = ( char * ) 0x0 ;
}
else {
pcVar2 = ( char * ) 0x0 ;
do {
if ( param_2 == cVar1 ) {
pcVar2 = param_1 ;
}
param_1 = param_1 + 1 ;
cVar1 = * param_1 ;
} while ( cVar1 != ' ' );
}
if ( param_2 != ' ' ) {
param_1 = pcVar2 ;
}
return param_1 ;
}การวิเคราะห์ต่อไปนี้ดำเนินการโดยใช้แบบจำลอง llama3.1:8b
ฟังก์ชั่นที่น่าสนใจ! ในฐานะผู้ช่วยวิศวกรย้อนกลับ ฉันจะแจกแจงว่าโค้ดนี้ทำหน้าที่อะไรและให้ข้อมูลเชิงลึกบางส่วน
ลายเซ็นฟังก์ชัน
char * FUN_801a7490(char *param_1,char param_2)ฟังก์ชันรับพารามิเตอร์สองตัว:
param_1: ตัวชี้ไปยังอาร์เรย์อักขระ (น่าจะเป็นสตริง)param_2: อักขระตัวเดียวฟังก์ชั่นร่างกาย
ฟังก์ชันทำหน้าที่ดังต่อไปนี้:
- จะตรวจสอบว่าอักขระตัวแรกของ
param_1(cVar1) คือหรือไม่ หากเป็นเช่นนั้นpcVar2จะถูกตั้งค่าเป็น(char *)0x0ซึ่งโดยพื้นฐานแล้วจะเป็น NULL- หาก
cVar1ไม่ใช่มันจะเข้าสู่ลูปโดยที่:
- ตรวจสอบว่าอักขระ
param_2ตรงกับอักขระปัจจุบันในparam_1(cVar1) หรือไม่ หากตรงกันpcVar2จะถูกตั้งค่าเป็นที่อยู่ของparam_1- ตัวชี้
param_1จะเพิ่มขึ้นทีละหนึ่งเพื่อชี้ไปยังอักขระถัดไปในสตริง- การวนซ้ำจะดำเนินต่อไปจนกระทั่งถึงจุดสิ้นสุดของสตริง (เช่น
cVar1กลายเป็น)
- หาก
param_2ไม่ใช่ null ฟังก์ชันจะส่งคืนที่อยู่ที่เก็บไว้ในpcVar2ข้อมูลเชิงลึก
จากรหัสนี้ ดูเหมือนว่าจะค้นหาอักขระ (
param_2) ภายในสตริง (param_1) การค้นหาจะหยุดทันทีที่พบอักขระนั้นตัวแรก
if (param_2 != ' ') { param_1 = pcVar2; }แสดงให้เห็นว่าหากพบparam_2ในสตริง ฟังก์ชันจะส่งตัวชี้ไปยังตำแหน่งนั้นภายในสตริง ถ้าไม่เช่นนั้น จะยังคงส่งคืนตัวชี้ที่ถูกต้อง (น่าจะชี้ไปที่จุดเริ่มต้นของสตริง)
GhidrOllama เปลี่ยนชื่อฟังก์ชันเป็น find_char_in_string
นี่คือฟังก์ชันที่แก้ไขพร้อมความคิดเห็นเพิ่มเติมเพื่ออธิบายลักษณะการทำงาน:
char * FUN_801a7490 ( char * param_1 , char param_2 ) { // Initialize a character variable (cVar1) to hold the first character of param_1. char cVar1 ; // Initialize a pointer variable (pcVar2) to point to null initially. char * pcVar2 ; // Assign the first character of param_1 to cVar1. This will be used as a starting point for searching in the string. cVar1 = * param_1 ; // Check if the input string (param_1) is empty (' '). if ( cVar1 == ' ' ) { // If it's empty, set pcVar2 to null, effectively indicating that no match was found. pcVar2 = ( char * ) 0x0 ; } else { // Initialize pcVar2 to null, which will be updated later if a match is found. pcVar2 = ( char * ) 0x0 ; // Loop through the string param_1 until we reach its end (' '). do { // Check if the current character (cVar1) matches the input parameter (param_2). if ( param_2 == cVar1 ) { // If it's a match, update pcVar2 to point to the beginning of param_1, effectively returning its address. pcVar2 = param_1 ; } // Move on to the next character in param_1 by incrementing its pointer (param_1 = param_1 + 1). param_1 = param_1 + 1 ; // Update cVar1 to hold the new current character. cVar1 = * param_1 ; } while ( cVar1 != ' ' ); } // Check if a match was found by verifying that param_2 is not null (' '). if ( param_2 != ' ' ) { // If it's not null, update param_1 to point to the matched string in pcVar2. param_1 = pcVar2 ; } // Return the address of the matched string or an empty string if no match was found. return param_1 ; }ดูเหมือนว่าฟังก์ชันนี้กำลังค้นหาอักขระตัวเดียว (param_2) ภายในสตริง (param_1) จะส่งคืนที่อยู่ของสตริงที่ตรงกัน หรือเป็นโมฆะหากไม่พบรายการที่ตรงกัน หากสตริงอินพุตว่างเปล่า ก็จะส่งกลับค่าว่างทันที
นี่คือฟังก์ชันที่เขียนใหม่พร้อมชื่อและความคิดเห็นที่สื่อความหมายมากขึ้น:
/** * Find the index of a given character in a string. * * @param str The input string to search in. * @param charToFind The character to find in the string. * * @return A pointer to the found character in the string, or NULL if not found. */ char * findCharacterInString ( char * str , char charToFind ) { // Initialize variables char currentChar ; char * foundCharPtr ; // Check if the input string is empty currentChar = * str ; if ( currentChar == ' ' ) { // If the string is empty, return NULL foundCharPtr = NULL ; } else { // Initialize pointer to point to end of string foundCharPtr = NULL ; // Loop through each character in the string do { // Check if current character matches the character to find if ( charToFind == currentChar ) { // If a match is found, update the pointer and break out of loop foundCharPtr = str ; break ; } // Move to next character in string str ++ ; currentChar = * str ; } while ( currentChar != ' ' ); } // Ensure that if charToFind is not empty, we return the pointer to the found character if ( charToFind != ' ' ) { str = foundCharPtr ; } // Return the pointer to the found character, or NULL if not found return str ; }โปรดทราบว่าฉันได้ใช้ชื่อฟังก์ชันที่สื่อความหมายมากขึ้น
findCharacterInStringและเพิ่มความคิดเห็นเพื่ออธิบายว่าแต่ละส่วนของโค้ดกำลังทำอะไรอยู่ ฉันยังใช้ชื่อตัวแปรที่สื่อความหมายมากขึ้นเช่นcurrentChar,foundCharPtr,strแทนcVar1,pcVar2เป็นต้น
ฉันให้โค้ดกับ GhidrOllama ที่ฉันรู้ว่ามีสแต็กโอเวอร์โฟลว์เพื่อดูว่าตรวจพบหรือไม่ และนี่คือคำตอบ:
ส่วนที่น่าสนใจที่อาจนำเสนอช่องโหว่ด้านความปลอดภัยในตัวอย่างโค้ดที่ให้มา:
NULL Pointer Dereference : ในฟังก์ชัน
upnp_device_discoveryมีความเป็นไปได้ที่ NULL pointer dereference เมื่อเข้าถึงiVar2ที่ออฟเซ็ต0x2910กรณีนี้อาจเกิดขึ้นได้หากDAT_8025d514น้อยกว่า 3 และ*(int *)(param_1 + 0x2910)ส่งคืนค่า NULL ในการแก้ไขปัญหานี้ ให้เพิ่มการตรวจสอบเพื่อให้แน่ใจว่าiVar2ไม่เป็น NULL ก่อนที่จะทำการยกเลิกการอ้างอิงif ( DAT_8025d514 < 3 && iVar2 != NULL ) { iVar2 = * ( int * )( param_1 + 0x2910 ); }Buffer Overflow : ในฟังก์ชัน
upnp_device_discoveryมีความเป็นไปได้ที่บัฟเฟอร์ล้นเมื่อเรียกstrcpy(auStack_98, iVar2 + 5);- สิ่งนี้สามารถเกิดขึ้นได้หากiVar2บวก 5 เกินขอบเขตของอาร์เรย์auStack_98เมื่อต้องการแก้ไขปัญหานี้ ให้เพิ่มการตรวจสอบเพื่อให้แน่ใจว่าบัฟเฟอร์ต้นทางและปลายทางไม่ใหญ่เกินไปสำหรับสตริงเป้าหมายif ( iVar2 != NULL && iVar2 + 5 <= iVar1 ) { strcpy ( auStack_98 , iVar2 + 5 ); }Use-After-Free : ในฟังก์ชัน
upnp_device_discoveryมีความเป็นไปได้ของ use-after-free เมื่อเข้าถึงiVar1หลังจากได้รับการปลดปล่อยในข้อมูลโค้ดต่อไปนี้:iVar1 = FUN_801a6bb4 ( iVar2 , s_urn_schemas_wifialliance_org_dev_801eb090 , 0x24 ); if ( iVar1 == 0 ) { iVar2 = iVar2 + 0x24 ; iVar1 = FUN_801a7114 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 ); }
iVar1ถูกปล่อยในบรรทัดที่กำหนดให้กับFUN_801a7114แต่ยังคงถูกใช้เป็นอาร์กิวเมนต์ในบรรทัดต่อไปนี้ เพื่อแก้ไขปัญหานี้ ให้กำหนดผลลัพธ์ของFUN_801a7114กลับไปเป็นiVar1ใหม่iVar1 = FUN_801a7114 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );การแทรก SQL : ในฟังก์ชัน
upnp_device_discoveryมีความเป็นไปได้ที่การแทรก SQL เมื่อเรียกใช้FUN_801a6bb4โดยมีอินพุตของผู้ใช้เป็นอาร์กิวเมนต์ เมื่อต้องการแก้ไขปัญหานี้ ให้ใช้แบบสอบถามแบบกำหนดพารามิเตอร์หรือคำสั่งที่เตรียมไว้เพื่อป้องกันการแทรก SQLiVar1 = FUN_801a6bb4 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );นี่คือช่องโหว่ด้านความปลอดภัยที่อาจเกิดขึ้นบางส่วนซึ่งสามารถพบได้ในข้อมูลโค้ดที่ให้มา
เราจะเห็นได้ว่าพบ Stack Overflow ในจุดที่ 2 ส่วนจุดอื่นดูเหมือนว่าจะตั้งสมมติฐานเกี่ยวกับพฤติกรรมที่ไม่ถูกต้องโดยสิ้นเชิง
สคริปต์ยังสามารถให้คำอธิบายคำแนะนำในหน้าต่างรายการ (บันทึกคู่มือการเรียกดูโปรแกรมเมอร์) นี่คือตัวอย่างสำหรับสิ่งนั้น:
movz v1, a0, v0
นี่คือคำตอบ:
คำสั่ง MIPS ที่น่ายินดี!
คำสั่ง
movz v1, a0, v0เป็นคำสั่งโหลด/จัดเก็บที่ดำเนินการย้ายจำนวนเต็มโดยมีการดำเนินการขยายเป็นศูนย์มาทำลายมันกัน:
movz: นี่คือตัวช่วยจำสำหรับคำสั่ง ซึ่งย่อมาจาก "move with zero-extend" ใช้ในการถ่ายโอนข้อมูลระหว่างรีจิสเตอร์ในขณะที่ขยายบิตเครื่องหมายv1,a0และv0เป็นชื่อรีจิสเตอร์ ใน MIPS เครื่องบันทึกเงินสดเหล่านี้มีบทบาทดังต่อไปนี้:
v1: การลงทะเบียนปลายทาง (ซึ่งผลลัพธ์จะถูกเก็บไว้)a0: Source register 1 (ประกอบด้วยค่าที่จะย้าย)v0: Source register 2 ไม่จำเป็นในกรณีนี้จุดประสงค์ของคำสั่งนี้คือการคัดลอกเนื้อหาของ
a0ลงในv1และขยายเครื่องหมายบิตของa0หากเป็นค่าลบ ผลลัพธ์จะถูกเก็บไว้ในv1เพื่อให้เข้าใจว่า "zero-extend" หมายถึงอะไร ลองพิจารณาตัวอย่าง:
สมมติว่า
a0มีค่า-5ในการเป็นตัวแทนไบนารี่ นี่คือ11111011เมื่อเราดำเนินการขยายค่าเป็นศูนย์กับค่านี้ เราจะเพิ่มศูนย์นำหน้าเพื่อให้เป็นจำนวนเต็ม 32 บิต ค่าไบนารีที่ได้จะเป็น00000000011111011ในตัวอย่างโค้ดแอสเซมบลี:
- สมมติว่าคุณมีค่าต่อไปนี้ในรีจิสเตอร์:
a0: -5 (ไบนารี่:11111011)v0ไม่ได้ใช้ในตัวอย่างนี้ จากนั้นหลังจากดำเนินการmovz v1, a0, v0รีจิสเตอร์v1จะมีค่า-5
- ตอนนี้สมมติว่าคุณมี:
a0: 17 (ไบนารี:00010001)- อีกครั้งไม่ได้ใช้
v0หลังจากรัน
movz v1, a0, v0แล้ว registerv1จะยังคงเก็บค่าไบนารีเดิมไว้ที่17เนื่องจากมันเป็นค่าบวกอยู่แล้ว และไม่ต้องการส่วนขยายที่เป็นศูนย์ใดๆ
- อีกตัวอย่างหนึ่งด้วย:
a0: -128 (ไบนารี:10000000)- อีกครั้งไม่ได้ใช้
v0หลังจากดำเนินการ
movz v1, a0, v0แล้ว registerv1จะมีค่า-128โปรดจำไว้ว่าใน MIPS คำสั่ง
movzสามารถย้ายระหว่างรีจิสเตอร์ที่มีขนาดเท่ากันเท่านั้น (จำนวนเต็ม 32 บิต) มูลค่าจะถูกโอนโดยตรงโดยไม่มีการแปลงหรือโปรโมชันใดๆโดยสรุป
movz v1, a0, v0ใช้เพื่อคัดลอกข้อมูลจำนวนเต็มจากรีจิสเตอร์หนึ่ง (a0) ไปยังอีกรีจิสเตอร์ (v1) โดยขยายบิตเครื่องหมายหากจำเป็น
ฉันขอให้โมเดลอธิบายชุดประกอบต่อไปนี้:
801a7490 00 00 82 80 lb v0,0x0(a0)
801a7494 00 2e 05 00 sll a1,a1,0x18
801a7498 0b 00 40 10 beq v0,zero,LAB_801a74c8
801a749c 03 2e 05 00 _sra a1,a1,0x18
801a74a0 21 18 00 00 clear v1
LAB_801a74a4 XREF[1]: 801a74b4(j)
801a74a4 26 10 a2 00 xor v0,a1,v0
801a74a8 0a 18 82 00 movz v1,a0,v0
801a74ac 01 00 84 24 addiu a0,a0,0x1
801a74b0 00 00 82 80 lb v0,0x0(a0)
801a74b4 fb ff 40 14 bne v0,zero,LAB_801a74a4
801a74b8 00 00 00 00 _nop
LAB_801a74bc XREF[1]: 801a74c8(j)
801a74bc 21 10 80 00 move v0,a0
801a74c0 08 00 e0 03 jr ra
801a74c4 0b 10 65 00 _movn v0,v1,a1
LAB_801a74c8 XREF[1]: 801a7498(j)
801a74c8 2f 9d 06 08 j LAB_801a74bc
801a74cc 21 18 00 00 _clear v1
นี่คือคำตอบ:
ข้อมูลโค้ดแอสเซมบลี MIPS!
ต่อไปนี้คือรายละเอียดว่าแต่ละคำสั่งทำอะไรได้บ้าง:
0x801a7490: ปอนด์ v0,0x0(a0)
lbคือคำสั่ง "load byte"v0คือรีจิสเตอร์ปลายทาง (เช่น ตำแหน่งที่ผลลัพธ์จะถูกจัดเก็บ)0x0(a0)คือที่อยู่ที่มีประสิทธิภาพของไบต์ที่จะโหลด ส่วน(a0)หมายความว่าควรเพิ่มค่าในรีจิสเตอร์a0ให้กับค่าทันที0x0เพื่อสร้างที่อยู่ที่มีประสิทธิภาพ- ดังนั้นคำสั่งนี้จะโหลดไบต์จากตำแหน่งหน่วยความจำ
a0 + 0 = a0ลงใน registerv00x801a7494: sll a1,a1,0x18
sllคือคำสั่ง "shift left logic"a1คือรีจิสเตอร์ต้นทาง (เช่น ค่าที่จะเลื่อน)- ค่าทันที
0x18ระบุจำนวนบิตที่จะเปลี่ยน ในกรณีนี้คือ 24 บิต (เนื่องจาก MIPS ใช้คำแบบ 32 บิต) ดังนั้นบิตทั้งหมดจึงกลายเป็นศูนย์อย่างมีประสิทธิภาพ- ดังนั้นคำสั่งนี้จะล้างบิตบนของ register
a10x801a7498: beq v0,ศูนย์,0x801a74c8
beqคือคำสั่ง "branch if equal"- มีการเปรียบเทียบตัวถูกดำเนินการสองตัวแรก หากพวกมันเท่ากัน (เช่น เป็นศูนย์ทั้งคู่) แล้ว...
- ...โปรแกรมแยกสาขาไปยังที่อยู่ที่ระบุโดยตัวถูกดำเนินการที่สาม: 0x801a74c8
0x801a749c: _sra a1,a1,0x18
- คำสั่งนี้คล้ายกับ
sllแต่เป็น "shift right arithmetic" เอฟเฟกต์จะเหมือนกับในคำสั่งก่อนหน้า0x801a74a0: ล้าง v1
_clear(สังเกตขีดล่าง) ล้างค่าของ registerv10x801a74a4: xor v0,a1,v0
xorเป็นคำสั่ง "พิเศษหรือ"- มีการเปรียบเทียบตัวถูกดำเนินการสองตัวแรก หากบิตใดบิตหนึ่งถูกตั้งค่าไว้ในตัวถูกดำเนินการตัวเดียว แต่ไม่ใช่ทั้งสองตัว ดังนั้น...
- ...บิตที่สอดคล้องกันในผลลัพธ์ (register
v0) ถูกตั้งค่าแล้ว0x801a74a8: movz v1,a0,v0
_movz(สังเกตขีดล่าง) โหลดคำจากตำแหน่งหน่วยความจำa0 + 0 = a0ลงใน registerv10x801a74ac: เพิ่ม a0,a0,0x1
addiuคือคำสั่ง "เพิ่มที่ไม่ได้ลงนามทันที"- ค่าในรีจิสเตอร์
a0จะเพิ่มขึ้น 10x801a74b0: ปอนด์ v0,0x0(a0)
- สิ่งนี้คล้ายกับคำสั่งแรก มันโหลดไบต์จากตำแหน่งหน่วยความจำ
a0 + 0 = a0ลงใน registerv00x801a74b4: bne v0,ศูนย์,0x801a74a4
bneคือคำสั่ง "สาขาถ้าไม่เท่ากัน"- ค่าในรีจิสเตอร์
v0จะถูกเปรียบเทียบกับศูนย์ หากมันไม่เท่ากัน (เช่นv0ไม่ใช่ศูนย์) ดังนั้น...- ...โปรแกรมจะแยกกลับไปที่ 0x801a74a4
0x801a74b8: _nop
_nopเป็นคำสั่งแบบ no-op ซึ่งไม่มีผลใดๆ0x801a74bc: ย้าย v0,a0
moveโหลดค่าของ registera0ลงใน registerv00x801a74c0: เจอาร์ รา
jrคือคำสั่ง "jump register"- โปรแกรมจะข้ามไปยังที่อยู่ที่เก็บไว้ใน register
raนี่อาจเป็นที่อยู่ผู้ส่ง ดังนั้นฟังก์ชันจะยุติลง0x801a74c4: _movn v0,v1,a1
_movnโหลดคำจากตำแหน่งหน่วยความจำa1 + 0 = a1ลงใน registerv00x801a74c8: เจ 0x801a74bc
- นี่คือเป้าหมายสาขาของคำสั่ง
beqแรก- โปรแกรมแตกสาขาเป็น 0x801a74bc
0x801a74cc: _เคลียร์ v1
_clearล้างค่าของ registerv1ดูเหมือนว่าโค้ดกำลังใช้การวนซ้ำบางประเภท เพิ่มตัวนับ (
a0) และทำการคำนวณตามค่าของมัน รายละเอียดไม่ชัดเจนโดยไม่มีบริบทเพิ่มเติม
สคริปต์นี้จัดทำขึ้นเป็นตัวอย่างและอาจต้องมีการแก้ไขเพื่อให้เหมาะกับกรณีการใช้งานเฉพาะหรือการเปลี่ยนแปลงใน Ollama API โปรดดูเอกสารประกอบ API สำหรับการอัปเดตหรือการเปลี่ยนแปลงใด ๆ
สคริปต์นี้ได้รับแรงบันดาลใจจากที่เก็บ GptHidra
สคริปต์นี้ยังใช้สคริปต์ Ghidra เวอร์ชันแก้ไขเล็กน้อยอีกด้วย
ขอขอบคุณผู้มีส่วนร่วมในโครงการเหล่านี้สำหรับการทำงานเบื้องต้น
