กลยุทธ์ในการเก็บรักษาข้อมูลลับเช่นคีย์ API อยู่นอกการควบคุมของแหล่งที่มาหรือไม่

ฉันกำลังทำงานบนเว็บไซต์ที่จะอนุญาตให้ผู้ใช้เข้าสู่ระบบโดยใช้ข้อมูลประจำตัว OAuth จาก Twitter, Google และอื่น ๆ ในการทำเช่นนี้ฉันต้องลงทะเบียนกับผู้ให้บริการที่หลากหลายเหล่านี้และรับคีย์ API ลับสุดยอดที่ฉันมี เพื่อปกป้องด้วยคำมั่นสัญญาจากส่วนต่างๆของร่างกาย หากคีย์ของฉันถูก ganked ส่วนนั้นจะถูกดึง

คีย์ API ต้องเดินทางไปพร้อมกับที่มาของฉันเนื่องจากมันถูกใช้ที่รันไทม์เพื่อทำการร้องขอการตรวจสอบสิทธิ์ ในกรณีของฉันคีย์ต้องมีอยู่ภายในแอปพลิเคชันในไฟล์กำหนดค่าหรือภายในโค้ดเอง นั่นไม่ใช่ปัญหาเมื่อฉันสร้างและเผยแพร่จากเครื่องเดียว อย่างไรก็ตามเมื่อเราส่งการควบคุมแหล่งที่มาลงในการผสมสิ่งต่าง ๆ ก็ซับซ้อนขึ้น

ในฐานะที่ฉันเป็นไอ้เลวราคาถูกฉันก็อยากใช้บริการควบคุมแหล่งข้อมูลฟรีเช่น TFS ในคลาวด์หรือ GitHub สิ่งนี้ทำให้ฉันมีปริศนาเล็กน้อย:

ฉันจะรักษาร่างกายของฉันให้เหมือนเดิมได้อย่างไรเมื่อคีย์ API ของฉันอยู่ในรหัสของฉันและรหัสของฉันจะมีอยู่ในที่เก็บสาธารณะ

ฉันสามารถนึกถึงวิธีการต่าง ๆ ในการจัดการกับสิ่งนี้ แต่ไม่มีวิธีใดที่น่าพอใจ

• ฉันสามารถลบข้อมูลส่วนตัวทั้งหมดจากรหัสและแก้ไขกลับมาหลังจากการใช้งาน นี่จะเป็นความเจ็บปวดที่รุนแรงในการติดตั้ง (ฉันจะไม่ให้รายละเอียดหลาย ๆ วิธี) และไม่ใช่ตัวเลือก
• ฉันสามารถเข้ารหัสได้ แต่เมื่อฉันต้องถอดรหัสมันทุกคนที่มีแหล่งที่มาสามารถคิดวิธีการดังกล่าว ไม่มีจุดหมาย
• ฉันสามารถจ่ายสำหรับการควบคุมแหล่งข้อมูลส่วนตัว ฮ่า ๆ j / k ใช้เงินไหม โปรด.
• ฉันสามารถใช้คุณสมบัติภาษาเพื่อแยกข้อมูลที่ละเอียดอ่อนออกจากส่วนที่เหลือของแหล่งข้อมูลของฉันและทำให้ไม่สามารถควบคุมแหล่งที่มาได้ นี่คือสิ่งที่ฉันทำตอนนี้ แต่มันอาจจะเมาอย่างง่ายดายโดยการตรวจสอบผิดในไฟล์ลับ

ฉันกำลังมองหาวิธีการรับประกันเพื่อให้แน่ใจว่าฉันจะไม่แบ่งปันทรัพย์สินส่วนตัวของฉันกับโลก (ยกเว้นใน snapchat) ที่จะทำงานได้อย่างราบรื่นผ่านการพัฒนาการแก้ไขข้อบกพร่องและการปรับใช้และจะเข้าใจผิดได้เช่นกัน นี่ไม่สมจริงอย่างสมบูรณ์ แล้วฉันจะทำอะไรที่แนบเนียน?

_{รายละเอียดทางเทคนิค: VS2012, C # 4.5, การควบคุมแหล่งข้อมูลอาจเป็นบริการ TF หรือ GitHub ขณะนี้ใช้คลาสบางส่วนเพื่อแยกคีย์ที่ละเอียดอ่อนออกในไฟล์. cs แยกที่จะไม่ถูกเพิ่มลงในการควบคุมแหล่งที่มา ฉันคิดว่า GitHub อาจมีข้อได้เปรียบเนื่องจากสามารถใช้. gignignore เพื่อให้แน่ใจว่าไฟล์คลาสบางส่วนไม่ได้เช็คอิน แต่ฉันเมาก่อนหน้านี้ ฉันหวังว่าจะเป็น "โอ้ปัญหาทั่วไปนี่คือวิธีที่คุณทำ" แต่ฉันอาจต้องจัดการเพื่อ "ที่ไม่ดูดมากเท่าที่จะมี",: /}

อย่าใส่ข้อมูลลับของคุณในรหัสของคุณ ใส่ไว้ในไฟล์กำหนดค่าซึ่งโค้ดของคุณอ่านเมื่อเริ่มต้น ไม่ควรวางไฟล์การกำหนดค่าไว้ในการควบคุมเวอร์ชันเว้นแต่ว่าเป็น "ค่าเริ่มต้นจากโรงงาน" จากนั้นไฟล์เหล่านั้นไม่ควรมีข้อมูลส่วนตัวใด ๆ

ดูเพิ่มเติมที่คำถามการควบคุมเวอร์ชันและไฟล์กำหนดค่าส่วนบุคคลสำหรับวิธีการทำเช่นนี้ได้ดี

คุณสามารถใส่คีย์ส่วนตัว / ป้องกันทั้งหมดเป็นตัวแปรสภาพแวดล้อมของระบบ ไฟล์กำหนดค่าของคุณจะมีลักษณะดังนี้:

private.key=#{systemEnvironment['PRIVATE_KEY']}

นี่คือวิธีที่เราจัดการกับกรณีเหล่านั้นและไม่มีอะไรเข้าสู่โค้ด มันทำงานได้ดีมากเมื่อรวมกับไฟล์คุณสมบัติและโปรไฟล์ต่างๆ เราใช้ไฟล์คุณสมบัติที่แตกต่างกันสำหรับสภาพแวดล้อมที่แตกต่างกัน ในสภาพแวดล้อมการพัฒนาท้องถิ่นของเราเราวางคีย์การพัฒนาในไฟล์คุณสมบัติเพื่อทำให้การตั้งค่าในเครื่องง่ายขึ้น:

private.key=A_DEVELOPMENT_LONG_KEY

วิธี Git บริสุทธิ์

• .gitignore ไฟล์ที่รวมอยู่กับข้อมูลส่วนตัว
• ใช้สาขาท้องถิ่นที่คุณแทนที่TEMPLATEด้วยDATA
• ใช้ตัวกรอง smudge / clean ซึ่งสคริปต์ของตัวกรอง (ภายในเครื่อง) ดำเนินการแทนที่แบบสองทิศทางTEMPLATE<->DATA

วิธี Mercurial

• MQ-patch (es) ที่ด้านบนของรหัสจำลองซึ่งแทนที่TEMPLATEด้วยDATA(เซ็ตการแก้ไขเป็นแบบสาธารณะส่วนแพตช์เป็นแบบส่วนตัว)
• ส่วนขยายคำหลักพร้อมคำหลักที่ออกแบบมาเป็นพิเศษ (ขยายเฉพาะในไดเรกทอรีทำงานของคุณ )

วิธี SCM ผู้ไม่เชื่อเรื่องพระเจ้า

• มีการแทนที่คำหลักซึ่งเป็นส่วนหนึ่งของกระบวนการสร้าง / ปรับใช้

ฉันใส่ความลับลงในไฟล์ที่เข้ารหัสซึ่งฉันจะส่ง วลีรหัสผ่านมีให้เมื่อระบบเปิดตัวหรือถูกเก็บไว้ในไฟล์ขนาดเล็กที่ฉันไม่ได้กระทำ เป็นเรื่องดีที่ Emacs จะจัดการไฟล์ที่เข้ารหัสเหล่านี้อย่างมีความสุข ตัวอย่างเช่นไฟล์ init ของ emacs รวมถึง: (โหลด "secret.el.gpg") ซึ่งใช้ได้เพียงแจ้งรหัสผ่านเกี่ยวกับเหตุการณ์ที่เกิดขึ้นได้ยากเมื่อฉันเริ่มแก้ไข ฉันไม่ต้องกังวลกับคนที่ทำลายการเข้ารหัส

นี่เป็นเฉพาะสำหรับ Android / Gradle แต่คุณสามารถกำหนดคีย์ในgradle.propertiesไฟล์โกลบอลของคุณuser home/.gradle/ได้ สิ่งนี้ยังมีประโยชน์เนื่องจากคุณสามารถใช้คุณสมบัติที่แตกต่างกันขึ้นอยู่กับ buildType หรือรสชาติเช่น API สำหรับ dev และอีกหนึ่งคุณสมบัติที่จะปล่อย

gradle.properties

MY_PRIVATE_API_KEY=12356abcefg

build.gradle

buildTypes {
        debug{
            buildConfigField("String", "GOOGLE_VERIFICATION_API_KEY", "\"" + MY_PRIVATE_API_KEY +"\"")
            minifyEnabled false
            applicationIdSuffix ".debug"
            }
        }

ในรหัสที่คุณต้องการอ้างอิงเช่นนี้

String myAPI = BuildConfig.GOOGLE_VERIFICATION_API_KEY;

คุณไม่ควรแจกจ่ายกุญแจนั้นพร้อมกับใบสมัครของคุณหรือเก็บไว้ในที่เก็บซอร์สโค้ด คำถามนี้ถามว่าจะทำอย่างไรและนั่นไม่ใช่สิ่งที่ปกติทำ

แอปพลิเคชันเว็บมือถือ

สำหรับ Android / iPhone อุปกรณ์ควรร้องขอ KEY จากบริการบนเว็บของคุณเองเมื่อมีการเรียกใช้แอปเป็นครั้งแรก คีย์จะถูกจัดเก็บในที่ปลอดภัย ผู้เผยแพร่ควรจะเปลี่ยนหรือเพิกถอนกุญแจได้หรือไม่ บริการเว็บของคุณสามารถเผยแพร่คีย์ใหม่

แอปพลิเคชันเว็บที่โฮสต์

ลูกค้าที่ใช้ลิขสิทธิ์ซอฟต์แวร์ของคุณจะต้องป้อนรหัสด้วยตนเองเมื่อทำการกำหนดค่าซอฟต์แวร์ครั้งแรก คุณสามารถให้คีย์เดียวกันกับทุกคนกุญแจที่แตกต่างกันหรือพวกเขาได้ของพวกเขาเอง

รหัสที่มาเผยแพร่

คุณจัดเก็บซอร์สโค้ดของคุณในที่เก็บสาธารณะ แต่ไม่ใช่ KEY ในการกำหนดค่าของไฟล์ที่คุณเพิ่มสาย* ที่สำคัญเกิดขึ้นที่นี่ * เมื่อนักพัฒนาใช้ซอร์สโค้ดของคุณพวกเขาจะทำสำเนาsample.cfgไฟล์และเพิ่มรหัสของตนเอง

คุณไม่เก็บconfig.cfgไฟล์ของคุณไว้ใช้สำหรับการพัฒนาหรือการผลิตในที่เก็บ

ใช้ตัวแปรสภาพแวดล้อมสำหรับสิ่งลับที่เปลี่ยนแปลงสำหรับแต่ละเซิร์ฟเวอร์

http://en.wikipedia.org/wiki/Environment_variable

วิธีใช้งานจะขึ้นอยู่กับภาษา

ฉันคิดว่านี่เป็นปัญหาที่ทุกคนประสบปัญหาในบางครั้ง

นี่คือขั้นตอนการทำงานที่ฉันใช้ซึ่งอาจใช้ได้ผลกับคุณ มันใช้. gignignore ด้วยการบิด:

1. ไฟล์การกำหนดค่าทั้งหมดไปในโฟลเดอร์พิเศษ (ด้วยไฟล์กำหนดค่าตัวอย่าง - ตัวเลือก)
2. ไฟล์การกำหนดค่าทั้งหมดจะรวมอยู่ใน. gitignore เพื่อไม่ให้เป็นสาธารณะ
3. ติดตั้งเซิร์ฟเวอร์ gitolite (หรือเซิร์ฟเวอร์ git ที่คุณชื่นชอบ) บนกล่องส่วนตัว
4. เพิ่ม repo ด้วยไฟล์ปรับแต่งทั้งหมดในเซิร์ฟเวอร์ส่วนตัว
5. เพิ่มสคริปต์เพื่อคัดลอกไฟล์กำหนดค่าไปยังโฟลเดอร์พิเศษใน repo หลัก (ตัวเลือก)

ตอนนี้คุณสามารถโคลน repo config กับระบบการพัฒนาและการปรับใช้ใด ๆ เพียงแค่เรียกใช้สคริปต์เพื่อคัดลอกไฟล์ไปยังโฟลเดอร์ที่ถูกต้องและคุณเสร็จแล้ว

คุณยังได้รับขนม GitHub ทั้งหมดแบ่งปันรหัสของคุณกับโลกและข้อมูลที่ละเอียดอ่อนไม่เคยอยู่ใน repo หลักดังนั้นพวกเขาจึงไม่เปิดเผยต่อสาธารณะ พวกเขายังคงเป็นเพียงการดึงและคัดลอกออกจากระบบการปรับใช้ใด ๆ

ฉันใช้กล่อง 15 $ / ปีสำหรับเซิร์ฟเวอร์ git ส่วนตัว แต่คุณสามารถติดตั้งที่บ้านได้ตามความต้องการของ cheapskate ;-)

PS: คุณยังสามารถใช้ submodule git ( http://git-scm.com/docs/git-submodule ) แต่ฉันมักจะลืมคำสั่งเสมอกฎที่รวดเร็วและสกปรก!

ใช้การเข้ารหัส แต่ให้คีย์หลักเมื่อเริ่มต้นเป็นรหัสผ่านที่คอนโซลในไฟล์เท่านั้นที่ผู้ใช้ของกระบวนการสามารถอ่านหรือจากที่เก็บคีย์ระบบที่จัดให้เช่นพวงกุญแจ Mac OS หรือที่เก็บคีย์ Windows

สำหรับการจัดส่งอย่างต่อเนื่องคุณจะต้องมีคีย์ต่าง ๆ ที่บันทึกไว้ที่ไหนสักแห่ง การกำหนดค่าควรถูกกำหนดเขตจากรหัส แต่มันค่อนข้างสมเหตุสมผลที่จะเก็บไว้ภายใต้การควบคุมการแก้ไข

3 กลยุทธ์ที่ยังไม่ได้กล่าวถึง (?)

เมื่อเช็คอินหรืออยู่ในตะขอเช็คอิน VCS ล่วงหน้า

• ค้นหาสตริงที่มีเอนโทรปีสูง, ตัวอย่าง - detect-secret
• regex ค้นหารูปแบบคีย์ API ที่เป็นที่รู้จักกันดี ปุ่ม AKIA * ของ AWS เป็นตัวอย่างหนึ่งความลับ gitเป็นเครื่องมือหนึ่งที่อ้างอิง นอกจากนี้ชื่อตัวแปรเช่น 'รหัสผ่าน' ที่มีการกำหนดค่าคงที่
• ค้นหาความลับที่รู้จัก - คุณรู้ความลับของคุณค้นหาข้อความสำหรับพวกเขา หรือใช้เครื่องมือฉันเขียนหลักฐานแนวคิดนี้

กลยุทธ์ที่กล่าวมาแล้ว

• เก็บในไฟล์ด้านนอกของทรีซอร์ส
• มีไว้ในซอร์สต้นไม้ แต่บอกให้ VCS เพิกเฉย
• ตัวแปรสภาพแวดล้อมเป็นรูปแบบของการจัดเก็บข้อมูลภายนอกแผนผังต้นไม้
• เพียงแค่ไม่ให้ความลับที่มีค่าแก่ผู้พัฒนา

ป้องกันไม่ให้ข้อมูลส่วนบุคคลออกจากการควบคุมแหล่งที่มาของคุณ สร้างค่าเริ่มต้นที่ไม่โหลดสำหรับการแจกจ่ายและให้ VCS ของคุณเพิกเฉยต่อของจริง กระบวนการติดตั้งของคุณ (ไม่ว่าจะด้วยตนเองกำหนดค่า / สร้างหรือตัวช่วยสร้าง) ควรจัดการการสร้างและการเติมไฟล์ใหม่ เลือกที่จะแก้ไขการอนุญาตบนไฟล์เพื่อให้แน่ใจว่าผู้ใช้ที่ต้องการเท่านั้น (เว็บเซิร์ฟเวอร์?) สามารถอ่านได้

ประโยชน์ที่ได้รับ:

• ไม่ถือว่าเอนทิตีพัฒนา == เอนทิตีผลิต
• ไม่ถือว่าผู้ทำงานร่วมกัน / ผู้ตรวจสอบรหัสทั้งหมดเชื่อถือได้
• ป้องกันข้อผิดพลาดง่าย ๆ โดยทำให้มันอยู่นอกเหนือการควบคุมเวอร์ชัน
• ง่ายต่อการติดตั้งอัตโนมัติด้วยการกำหนดค่าที่กำหนดเองสำหรับ QA / สร้าง

หากคุณกำลังทำสิ่งนี้อยู่และกำลังตรวจสอบโดยไม่ได้ตั้งใจให้เพิ่มลงในโครงการของ.gitignoreคุณ สิ่งนี้จะทำให้เป็นไปไม่ได้ที่จะทำอีกครั้ง

มีอยู่มากมายของโฮสต์ Git ฟรีรอบที่ให้พื้นที่เก็บข้อมูลส่วนตัว แม้ว่าคุณไม่ควรอัปเดตข้อมูลประจำตัวของคุณคุณสามารถถูกและมี repos ส่วนตัวเช่นกัน ^ _ ^

แทนที่จะเก็บคีย์ OAuth ไว้เป็นข้อมูลดิบทำไมไม่เรียกใช้สตริงผ่านอัลกอริธึมการเข้ารหัสและเก็บไว้เป็นแฮชเค็ม จากนั้นใช้ไฟล์กำหนดค่าเพื่อกู้คืนเมื่อรันไทม์ ด้วยวิธีนี้คีย์จะไม่ถูกเก็บไว้ที่ใดก็ตามไม่ว่าจะถูกเก็บไว้ในกล่องพัฒนาหรือเซิร์ฟเวอร์เอง

คุณยังสามารถสร้าง API เพื่อให้เซิร์ฟเวอร์ของคุณสร้างคีย์ API แบบเค็มและแบบแฮชใหม่โดยอัตโนมัติตามการร้องขอต่อไปวิธีนี้จะทำให้ทีมของคุณไม่เห็นแหล่ง OAuth

แก้ไข: ลองใช้Stanford Javascript Crypto Libraryซึ่งจะช่วยให้การเข้ารหัส / ถอดรหัสสมมาตรมีความปลอดภัย