<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Larry Lu on Medium]]></title>
        <description><![CDATA[Stories by Larry Lu on Medium]]></description>
        <link>https://medium.com/@larry850806?source=rss-c3d4e0232dc0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ti9wWeiCLA2dhU9ewpFhtQ.jpeg</url>
            <title>Stories by Larry Lu on Medium</title>
            <link>https://medium.com/@larry850806?source=rss-c3d4e0232dc0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 18:14:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@larry850806/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[善用 Go Fuzzing，幫助你寫出更完整的單元測試]]></title>
            <link>https://medium.com/starbugs/utilize-go-fuzzing-to-write-better-unit-tests-80bd37cd4e38?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/80bd37cd4e38</guid>
            <category><![CDATA[go]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Mon, 31 Oct 2022 07:38:11 GMT</pubDate>
            <atom:updated>2022-11-01T04:31:25.544Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CPS-1ZfQjS-NuMvrF4fh_Q.png" /></figure><p>前陣子小弟我有幸收到 MOPCON 的邀約，去擔任今年的年會講者，分享的題目就是 Go 在今年三月推出的新 feature — <strong>Fuzzing Test（模糊測試）</strong>，是一種跟單元測試截然不同的測試方式。</p><p>為了讓更多人知道 Fuzzing 這個有趣的新功能（以及拯救我快要沒靈感的專欄XD），今天這篇文章會用在 MOPCON 上講到的幾個例子，一步一步帶大家認識 Go Fuzzing</p><h3>Unit Testing</h3><p>首先介紹一下今天要講的例子：就只是一個非常簡單的 pow(x, y) 函數，內部實作是用遞迴來計算 x 的 y 次方，就算沒寫過 Go 應該也看得懂～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GTSVlPK_rwTNphURkgy-HQ.png" /></figure><p>那如果我們要幫這個 pow(x, y) 寫單元測試，可能會怎麼寫呢？</p><p>無非就是找幾個簡單的例子測試看看（下圖），譬如說「1⁵ 是 1」、「2⁰ 是 1」、「2¹⁰ 是 1024」等等。如果這幾個例子都沒問題，那我們就相信這個 pow(x, y) 應該沒有寫錯。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KyaREsuyo3m6Zs3fD7tj7w.png" /></figure><p>但我們重新思考一下，像這樣的單元測試可能有怎麼樣的問題：</p><p>首先是「需要幾個 test case 才能夠確保正確性？」，像上圖的單元測試只測了四組 input/output，如果這樣就說 pow(x, y) 的實作是完全正確的，顯然有點沒說服力XD。</p><p>再來是，<strong>通常我們在幫自己的程式寫單元測試時，並不容易想到各種 edge case</strong>，所以很常會發生「我之前測都沒問題」但是到使用者那邊就因為奇怪的輸入跟行為而炸掉。</p><h3>Fuzzing Test</h3><p>而 Go 在版本 1.18 推出的 Fuzzing 正好彌補了單元測試不足的部分。Fuzzing 是一種自動化的測試技術，<strong>他會不斷不斷的丟各種隨機生成的 input 給你</strong>，讓你拿去做測試。</p><p>下面這段程式碼，就是請 Go 的 Fuzzing engine 每次都幫我們隨機生成一個 unsigned int 叫做 x（第二行），接著用這個隨機生成的 x 去做 assert。但這邊有個跟單元測試很不一樣的地方：<strong>因為我們並不知道 x 是多少（畢竟是隨機生的嘛），所以我們必須在不知道 x 是多少的情況下去寫 assert</strong>。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KBfXlIJWoGTlD6xi1KgBVQ.png" /></figure><p>雖然聽起來有點荒謬，連輸入都不知道那我是要測個鬼啊！？但其實是可以的哦，只是要用一些旁敲側擊的方式去寫 assert。譬如說我們知道「不管 x 是多少，pow(x, 0) 一定等於 1（第五行）」、「不管 x 是多少，pow(x, 1) 一定等於 x 本身」。</p><p>用這樣的方式，<strong>我們就可以在「不知道 x 是多少」的前提下，去驗證 </strong><strong>pow(x, y) 有沒有寫錯</strong>，如果在某些特殊情況下 pow(x, 0) 算出來不等於 1，那就代表 pow(x, y) 鐵定是寫錯了嘛！</p><p>寫完 Fuzzing Test 後馬上到終端機下 go test -fuzz=Fuzz -fuzztime 20s 跑跑看，因為 Fuzzing engine <strong>會不斷生成隨機的輸入</strong>，所以要限制他跑 20 秒就好，不然他就會一直跑一直跑直到找到錯為止～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yvsd2rEjjai6R4pucw2kIw.png" /></figure><p>仔細看一下跑的結果，這 20 秒的時間他執行了 1044100 次的測試（倒數第三行），也就是 Fuzzing engine 總共生成了一百多萬個隨機的 x，然後丟進去我們寫的三個 assert 做驗證，最後都順利 PASS 了 🎉 🎉 🎉</p><h3>More Fuzzing Test</h3><p>但光是測這三個簡單的 assert 好像沒什麼說服力，所以接著我們來加一些更複雜的條件。我們想要測試的是：<strong>當隨機的 x 跟 y 都大於零時，「x 的 y 次方再除以 x」一定要等於「x 的 y-1 次方」</strong>。這應該滿好理解的，就像 2¹⁰/2 就是 2⁹ 也就是 512。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lRs_4NP7r0ySHpkLb6ZYIQ.png" /></figure><p>這個 assert 聽起來聽經地義，而且也是會寫在國中課本上的東西，實際跑跑看卻不知為何 FAIL 了，難道是以前數學課都教錯了嗎？</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-HufLNbSkpvBZgkBE-iefw.png" /></figure><p>在做 Fuzzing Test 的時候如果跑一跑 FAIL 了，Go 會幫忙把那組 input 記在 testcase/ 裡面，所以先別急著下定論，我們來看一下到底是怎麼樣的 x 跟 y 會讓這個 assert 失敗。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sScLt75OlrfSj-ydy1RjGw.png" /></figure><p>看了之後會發現在 x=6、y=30 時 assert 會失敗，<strong>也就是說 </strong><strong>pow(6, 30)/6 不會等於 </strong><strong>pow(6, 29)</strong>。但這也太奇怪了吧？仔細實驗之後才發現是因為在計算 pow(6, 30) 的時候會發生 overflow。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*V0qIQN1q_i5XkZHAH3FZmg.png" /></figure><p>因為 Go 定義的 <a href="https://pkg.go.dev/math#MaxUint">max.MaxUint</a> 大約是 18 * 10¹⁸，但 6²⁹ 大概是 7 * 10¹⁸。<strong>如果把 6²⁹ 再乘上 6，就會發生 overflow 得到 8 * 10¹⁸，很像繞了操場兩圈結果在跟原本差不多的位置。</strong></p><p><strong>所以如果把 overflow 過的 6³⁰ 拿去除以 6，就會跟 6²⁹ 不一樣</strong>。這就是 Fuzzing 幫我們找到的 edge case，也是我們當初沒想到的。</p><h3>Improved Pow</h3><p>仔細想想，<strong>pow(x, y) 在計算的過程中會不會發生 overflow 完全取決於使用者的輸入是多少</strong>。因此我們不可能避免 overflow，但至少我們能在 overflow 發生時讓使用者知道，而不是已經乘到 overflow 還繼續裝沒事，<strong>這樣可能有天會導致我們想都沒想過的 bug。</strong></p><p>依循這個想法，<strong>我們可以幫 pow 多加一個 error type 的回傳值</strong>，如果在計算的過程中不幸發生 overflow，就可以回傳 ErrOverflow，讓使用者自己決定要怎麼處理。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7czdXE191ApZs2UnjVJJ9A.png" /></figure><p>既然 pow(x, y) 的實作改了，那測試當然也要改一下：單元測試的部分除了驗證結果之外，還要檢查看看有沒有錯誤，像 pow(2, 10) 就不應該有錯誤、而 pow(6, 30) 則會得到 ErrOverflow。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GHlrmFB6tXQXlqz83raKyA.png" /></figure><p>下面的 Fuzzing Test 也是，如果在計算過程中已經發生 overflow，算出來的結果自然是錯誤的，所以我們就不去跑 assert 了。但如果沒發生 overflow，那該做的 assert 還是要做。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3P75Q_ClxzrLv2RpGGQZMg.png" /></figure><p>處理完 overflow 的問題之後再跑一次 Fuzzing Test，馬上就過了～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZTL_YTmn48kWifVjKlxcbQ.png" /></figure><p>這邊來回顧一下，在整個測試 pow(x, y) 的過程中，<strong>Fuzzing 最大的貢獻就是幫我們找出「</strong><strong>pow(6, 30) / 6 不等於 </strong><strong>pow(6, 29)」這個 edge case</strong>，從而讓我們去思考當 overflow 發生時，是不是應該要 return 一個 ErrOverflow 讓使用者去處理。真的很不錯～</p><h3>Comparison</h3><p>到這邊如果都有看懂的話，不難發現 Unit Test 跟 Fuzzing 在測試的方式很不一樣：首先是 Unit Test 就是固定那幾個 test case，<strong>而 Fuzzing 是每次會不斷給你隨機生成的 input 去測試，因此更容易找到 edge case</strong>，這是 Fuzzing 的優點。</p><p>再來是當我們在做 Unit Test 時，我們都是直接驗證答案是多少，譬如說我們知道「pow(2, 10) 就是 1024」，所以就直接 assert(pow(2, 10), 1024)。</p><p>但在做 Fuzzing Test 的時候，<strong>我們根本不知道輸入的 x、y 是多少</strong>，所以我們只能在不知道輸入的情況下，<strong>用答案的性質（property）或是數學定理來 assert</strong>，譬如說「任何數的 0 次方都是 1」、「x 的 y 次方再除上 x 會變成 x 的 (y-1) 次方」這樣拐彎抹角的方式，所以寫起來會比較困難、迂迴一點。</p><h3>Trophies</h3><p>因為今天講的 pow 滿簡單的，大家可能還感覺不到 Fuzzing Test 的威力，這邊帶大家來看一下 Fuzzing 曾經發現過怎麼樣的 bug。</p><h4><a href="https://github.com/golang/go/issues/11597">compile: hangs converting int const to complex64</a></h4><p>首先這個例子是，Go 1.6 的編譯器在編譯下面這個程式時（沒錯就只有兩行）會直接卡住。通常編譯器的工作就是要<strong>把正確的程式碼編譯成執行檔、若是程式碼有錯則是要顯示編譯失敗</strong>。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tmji_qfCHsAtK8dMygBJeg.png" /></figure><p>但上面這個程式一編譯下去就「卡住了」，沒錯就是卡住XD，可能在什麼地方進入了無窮迴圈或是 deadlock，所以一動也不動。</p><h4>constant: hang evaluating “-6e-1886451601”</h4><p>而另外下面這個例子是在 Go 1.9 中，雖然通過編譯了，但程式只要一跑下去就會直接當掉，永遠沒有結束的一天。但我不過是想宣告一個常數而已…怎麼就掛了QQ</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Tp1-ABobnzCJjeuGkBBi6g.png" /></figure><p>而這兩個例子的共通點是：雖然他們的程式碼很短，<strong>但裡面都有一些怪怪的數字。因此如果不利用 Fuzzing 丟隨機的 input 進去跑，光靠人為方式是很難找到這種 bug 的</strong>，也再次驗證了 Fuzzing 在找 edge case 上非常厲害。</p><p>如果有興趣的話，<a href="https://github.com/dvyukov/go-fuzz#trophies">go-fuzz#trophies</a> 這邊也可以看到更多 Go Fuzz 曾經發現過的問題，到目前為止已經在 Go compiler 跟內建 library 發現超過四百個 bug，真的很厲害哦～</p><h3>Summary</h3><p>雖然平常不容易遇到，<strong>但當很多 edge case 層層疊加起來是有可能造成安全漏洞的</strong>，像幾年前的新聞<a href="https://docs.google.com/presentation/d/1U8caM4tzurBaOjuJZfXA7h2uBmLmgoZQQC48nPbokyw/edit?pli=1#slide=id.g1658f38052f_0_55">〈果粉快注意！一封簡訊就可搞掛你的 iPhone〉</a>就是在說只要用簡訊傳一段怪怪的英文 + 阿拉伯文（？） + 中文給那些愛炫耀新 iPhone 的朋友，對方的手機就會馬上關機而且簡訊 App 再也打不開。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*vBAo30NgpPvFNS3TMZsf5w.png" /></figure><p><strong>像這類出現在 Application Level 的攻擊很多都是透過觸發底層 lib 的 edge case 來達到的</strong>，因此平常在寫這些 library 時也必須格外小心。</p><p>最後想補充一下，Fuzzing Test 雖然是比較新的東西，<strong>但他並不是用來取代 Unit Test 的，他只是利用大量隨機的輸入來幫你找到可能有問題的 edge case。</strong></p><p><strong>找到 edge case 後你還是要把他們加進單元測試裡面，讓你的單元測試變得更健壯</strong>，就如同這篇的標題說的「善用 Go Fuzzing，幫助你寫出更完整的單元測試」，因此兩者沒有誰強誰弱，是相輔相成的關係哦～</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80bd37cd4e38" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/utilize-go-fuzzing-to-write-better-unit-tests-80bd37cd4e38">善用 Go Fuzzing，幫助你寫出更完整的單元測試</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[道理我都懂，但 Stack 到底為什麼會 Overflow]]></title>
            <link>https://medium.com/starbugs/why-does-stack-overflow-occur-1f93e3035e9d?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f93e3035e9d</guid>
            <category><![CDATA[starbugs]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Sun, 18 Sep 2022 02:05:08 GMT</pubDate>
            <atom:updated>2022-09-18T02:05:08.400Z</atom:updated>
            <content:encoded><![CDATA[<p>身為工程師，<a href="https://stackoverflow.com/">Stack Overflow</a> 這網站大家應該都是熟到不能再熟。如果沒有他幫忙解決各種莫名其妙的錯誤訊息，可能連設定個開發環境都要搞半天，更不用說要開發了，產出直接降低好幾倍，不如直接放工程師下班算了。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/455/1*tm-nO1eNGvLaCqCZN7LxFQ.png" /><figcaption><a href="https://buzzorange.com/techorange/2021/06/07/stack-overflow-acquired/">https://buzzorange.com/techorange/2021/06/07/stack-overflow-acquired/</a></figcaption></figure><p>但今天要談的不是那個 Stack Overflow，而是要講程式在使用記憶體時，<strong>因為 call stack 堆太高了不小心把記憶體用完，所產生的 overflow。</strong></p><p>先來看看以下這個用 JS 寫成的 sum(n)，他做的事情很簡單，就只是用遞迴來計算從 1 到 n 的總和，譬如說 sum(3) = 1 + 2 + 3 = 6。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a93f0f3f2aaeedb03fc23769c9f5661/href">https://medium.com/media/3a93f0f3f2aaeedb03fc23769c9f5661/href</a></iframe><p>這寫法很爛我知道，不過為了示範請大家包容一下XD，實際跑跑看 sum(10) 跟 sum(10000) 也都有得到正確的結果。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*Zv51hqQ1AI8EXGXA2rgFjw.png" /></figure><p>但跑 sum(20000) 時就不是這樣了，<strong>因為程式寫太爛加上 20000 這數字太大</strong>，直接就原地炸開噴出 RangeError: Maximum call stack size exceeded，這就是所謂的 Stack Overflow。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/973/1*s1F9hj0BDFgW7ZztVpc4pA.png" /></figure><h3>Stack in memory layout</h3><p>看過 Stack Overflow 之後，我們來講解一下他的成因，首先看看到底什麼是 Stack。每個 Process 在啟動時，系統都會分配一塊記憶體給他使用，以最常見的 memory layout 來說，Process 內的 memory layout 大概會長這樣，<strong>由低位到高位主要分成 Text、Data、Heap、Stack 幾個區塊。</strong></p><p>最下面的 Text 區塊放的是要給 CPU 跑的 executable instruction，一般來說你的程式碼越多，這部分就會越肥；而 Data 區塊放的就是 process 內的全域、靜態變數，有設定初始值的就會被放在 <strong>Initialized</strong>，沒有的話就是在 <strong>Uninitialized</strong>，程式啟動時會把他們的值清空成 0。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FmKeZrrhSnZWe95uFxgjqw.png" /></figure><p><strong>Text 跟 Data 這兩個區塊基本上是固定大小</strong>，因為你寫的程式一旦編譯好，程式碼跟全域變數的數量就會固定下來，不太會動態增長。但 Heap 跟 Stack 就不一樣了，當程式有用到動態記憶體配置像是 C 語言的 <a href="https://openhome.cc/Gossip/CGossip/MallocFree.html">malloc/free</a>、Rust 的 <a href="https://doc.rust-lang.org/rust-by-example/std/box.html">Box</a>，那些空間就會被分配在 Heap 裡面。</p><p>而最上面的 Stack 也就是這篇的重點，<strong>則是放 call function 時會用到的一些東西</strong>，像是傳進來的參數、自己宣告的變數等等，<strong>每個 function 啟動時會有一個 stack frame 被創造出來，結束時再馬上釋放掉</strong>。</p><h3>Deep Recursive Function</h3><p>那遞迴是怎麼讓 Stack 爆掉的呢？以我們的例子來說，當我們呼叫 sum(3) 時，他內部會先呼叫 sum(2)，而 sum(2) 又再呼叫 sum(1)，因此整個 Stack 裡面會有多個 stack frame 依序疊起來，<strong>只有當最上層的 sum(1) 執行結束了之後，才有辦法繼續執行下面的 sum(2) 跟 sum(3)。</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HCutX41tEmDGY-pgao_0rA.png" /></figure><p>雖然 stack 可以動態增長，但他的大小也是有極限的，作業系統總不可能為了跑你的程式而把整台電腦的 memory 都給你。</p><p>因此當你呼叫 sum(20000) 導致遞迴太深時，等待執行的 function 有太多，<strong>但 stack 已經裝不下更多 frame，就會產生 overflow 的錯誤</strong>，仔細看一下是不是跟 Stack Overflow 的 logo 有 87% 像呢XD</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7P1a26sxl4-zUMkLhhSFqQ.png" /></figure><p>雖然一般來說都是遞迴沒寫好才會導致 Stack Overflow，但其實 Stack Overflow 並不一定是遞迴造成的，只要你的 call stack 夠深（真的要非常非常深），那就可能會有這個。</p><h3>How to fix Stack Overflow</h3><p>若真的不幸遇到 Stack Overflow 要怎麼解決呢？第一步就是先<strong>檢查遞迴的終止條件</strong>。像這邊如果沒有在 n == 1 時 return 1，那就算只是跑個 sum(3) 也會炸掉。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3ee11e80b906ec95a1a15938d5230303/href">https://medium.com/media/3ee11e80b906ec95a1a15938d5230303/href</a></iframe><p>如果檢查後都沒有寫錯，但參數太大時還是會爆掉，那就是得想辦法<strong>把遞迴攤平成迴圈了</strong>，像 sum 很明顯就可以用一個迴圈或是公式解把它做完：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/95098c9e60973ff15e978597dad9b940/href">https://medium.com/media/95098c9e60973ff15e978597dad9b940/href</a></iframe><p>那如果像是 Merge Sort 這種比較難直覺攤平成 loop 的演算法呢？</p><p>通常這種被廣泛使用的演算法的 call stack 都不會太深，因為這類演算法為了加速都會大量使用 <a href="https://zh.wikipedia.org/zh-tw/%E5%88%86%E6%B2%BB%E6%B3%95">Divide and Conquer</a> 的技巧，像 Merge Sort 就會不斷把 array 切成兩半。因此除非你的資料量有超過 2¹⁰⁰⁰⁰ <strong>≈ </strong>10³⁰¹⁰ 筆，否則 call stack 再深也不可能超過電腦的限制。</p><p>所以如果你自己寫的 Merge Sort 不知道為啥跑起來會 Stack Overflow，不用懷疑，百分之百是你寫錯了XD</p><h3>Summary</h3><p>下次再有人問你「工程師賴以為生的 Stack Overflow 到底是什麼意思啊？」，相信大家應該都可以輕鬆講出來了。</p><p>因為這篇是用 Node.js 來展示 Stack Overflow 的錯誤，所以實際的 memory layout 可能跟上面畫的有些許不同（每個語言都有自己一套管理記憶體的方式），<strong>但概念基本上都是相通的</strong>。</p><p>今天講完 Stack Overflow，下次有空時應該會再延續這個主題，寫一篇關於尾遞迴最佳化（Tail Call Optimization）的文章，大家敬請期待啦～</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f93e3035e9d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/why-does-stack-overflow-occur-1f93e3035e9d">道理我都懂，但 Stack 到底為什麼會 Overflow</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[人生不能黑白，終端機當然也是]]></title>
            <link>https://medium.com/starbugs/use-escape-sequence-to-make-terminal-colorful-3aefd458d391?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/3aefd458d391</guid>
            <category><![CDATA[terminal]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Mon, 15 Aug 2022 05:37:42 GMT</pubDate>
            <atom:updated>2022-08-15T05:38:18.027Z</atom:updated>
            <content:encoded><![CDATA[<p>不知道大家有沒有用過 <a href="https://github.com/ogham/exa">exa</a> 這個 CLI 工具，他基本上是現代版的 ls（我都直接 alias ls=&#39;exa -h&#39;）。除了是用 Rust 寫的所以效能很好之外，他還會幫結果上色，讓眼睛看起來更舒服，同事不經意看到你的螢幕時也會覺得你很厲害（X</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tg3Skv6bNKuyyqnKAk-rNg.png" /></figure><p>不過今天的重點不是 exa，而是為什麼 exa 的輸出可以這麼<strong>五彩繽紛</strong>甚至還能<strong>畫線</strong>？這就要從 <strong>跳脫序列</strong>（Escape Sequence） 開始說起了</p><h3>ANSI Escape Sequence</h3><p>第一次聽到<strong>跳脫序列</strong>（Escape Sequence）可能會不知道那是啥，但我們其實很常用到它哦～</p><p>像大家都知道在寫程式的時候 \n 代表的是換行、而 \t 是 Tab。這類型 \ 開頭的字元就被稱做<strong>跳脫字元</strong>。\n 並不是字面上的 \ 跟 n 兩個字元，而是有特別的換行功能，所以如果在終端機中下指令 echo -e &quot;Hello\nWorld&quot; 會看到 Hello 跟 World 是各自一行</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*quzKTITHFhTJOtzgxNTKaA.png" /></figure><p>但除了 \n 跟 \t 之外其實還有各種奇怪的跳脫字元，而且也不一定都短短的，像<strong>顏色</strong>也是用跳脫字元來實現的。舉個例子，像 <strong>\033[34m</strong> 這一串可以把之後的字變成<strong>藍色</strong>，可以想像成把手上的筆換成藍色的，而 <strong>\033[0m</strong> 則是把顏色<strong>重置</strong>。</p><p>所以 <strong>\033[34m</strong>Hello<strong>\033[0m</strong>World 這一大串就是<strong>先拿藍色的筆寫 </strong>Hello，<strong>換回原本的筆後再寫 </strong>World，因此只有前面的 Hello 變成藍色，很神奇吧！</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v2s1vssLSaRqQYX67O7XJw.png" /></figure><h3>CSI Sequence</h3><p>像 <strong>\033[34m</strong> 跟 <strong>\033[0m</strong> 這種格式被稱作 <a href="https://zh.wikipedia.org/zh-tw/ANSI%E8%BD%AC%E4%B9%89%E5%BA%8F%E5%88%97#CSI%E5%BA%8F%E5%88%97">CSI 序列</a>，他們的共通點是都是以 <strong>\033[</strong> 開頭、以 <strong>m</strong> 結尾，中間再填上 <strong>SGR 參數</strong>，用來設定你想把輸出變成什麼顏色。</p><p>那每個數字到底代表什麼顏色呢？我們一起來看看<a href="https://zh.wikipedia.org/zh-tw/ANSI%E8%BD%AC%E4%B9%89%E5%BA%8F%E5%88%97#%E9%A2%9C%E8%89%B2">維基上的顏色表</a>，可以看到 <strong>34</strong> 對應到的是 <strong>前景色代碼的藍色</strong>，因此 \033[ <strong>34 </strong>m 就是把字體顏色設為藍色。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o262NfIFSIphLiXO-p_6HQ.png" /></figure><p>那如果你想要的是 <strong>黃底藍字 </strong>呢？那就用分號 ; 把黃色背景（43）跟藍字（34）串起來作為 SGR 參數就可以了。實際用 \033[<strong>34;43</strong>mHelloWorld 馬上就可以看到黃底藍字的 Hello World 哦～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6WyzPGa0MvmFolMz97Sa_Q.png" /></figure><p>除了顏色之外，<a href="https://zh.wikipedia.org/zh-tw/ANSI%E8%BD%AC%E4%B9%89%E5%BA%8F%E5%88%97#%E9%80%89%E6%8B%A9%E5%9B%BE%E5%BD%A2%E5%86%8D%E7%8E%B0%EF%BC%88SGR%EF%BC%89%E5%8F%82%E6%95%B0">SGR 參數</a>還可以用來調整很多東西哦，像是 1 是粗體、3 是斜體、9 是刪除線等等</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GEnaCpBLdh5Ys8xj0xZiFA.png" /></figure><p>所以你也可以把他們組起來做出 <strong>又斜又粗黃底藍字加刪除線</strong> 的 Hello World</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tXWgfv3Vjc2WEIu9SVJKGQ.png" /></figure><p>因為像這種跳脫字元是通用的，所以不管你寫的是什麼語言都可以用這種方式來上色，像我把上面那串貼到 Node.js 裡面去跑，就會出現漂亮（？）的 Hello World</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Md6UVt6-LOGGy3_KWAJ2zw.png" /></figure><h4>蛤可是這樣寫起來好醜</h4><p>雖然說可以這樣幫輸出結果加上顏色，可是程式碼會看起來很醜，不仔細看根本不知道在寫什麼。所以其實各語言都有一些包裝好的 library 可以用，像 JS 就是用 <a href="https://github.com/chalk/chalk">chalk</a>，輕輕鬆鬆就可以上色</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HD-jE9NsFxvoONwiRWFF8w.png" /></figure><p>如果仔細去看 chalk 的<a href="https://github.com/chalk/chalk/blob/main/source/vendor/ansi-styles/index.js#L3-L32">原始碼</a>，會發現他就是把上面那串 \033[ <strong>&lt;SGR&gt;</strong> m 包裝成一個個 function 讓你方便用而已，所以最後的效果都是一樣的</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XCdBzo9lXsAmZzdsnO4egQ.png" /></figure><p>如果不是寫 JS 的話，像 Go、Rust、Python 也有 <a href="https://github.com/fatih/color">color</a>、<a href="https://crates.io/crates/ansi_term">ansi_term</a> 跟 <a href="https://github.com/bluenote10/yachalk">yachalk</a> 可以用。下面是 Rust 的 <a href="https://crates.io/crates/ansi_term">ansi_term</a> 提供的寫法，也是輕輕鬆鬆～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ihl3DULgU5sjDakq8-PjhQ.png" /></figure><p>而 <a href="https://github.com/ogham/rust-ansi-term/blob/master/src/ansi.rs#L82-L96">Rust ansi_term 的實作</a> 也是差不多的方式，就是幫你把這堆醜東西封裝起來，眼不見為淨XD</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BI7Vr9ZEGn5n1PjHpZbEEg.png" /></figure><h4>總結</h4><p>關於可以用 Escape Sequence 來上色這件事，之前參加鐵人賽的時候就簡單寫過～但那時每天都要寫文章沒時間研究得更深入。這次除了教大家怎麼用 SGR 參數之外，還稍微看了 JS 跟 Rust 的 color library 實作，雖然內容不難，但我自己覺得滿有趣的</p><p>雖然今天只跟大家介紹 30 到 37 共八種顏色可以用，但隨著現在越來越多終端機支援 256 色，有興趣的話也可以到 <a href="https://zh.wikipedia.org/zh-tw/ANSI%E8%BD%AC%E4%B9%89%E5%BA%8F%E5%88%97#8%E4%BD%8D">wiki</a> 上面看怎麼使用更多其他的顏色，就可以讓終端機的顏色更豐富哦～</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3aefd458d391" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/use-escape-sequence-to-make-terminal-colorful-3aefd458d391">人生不能黑白，終端機當然也是</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[只要十分鐘，帶你看懂 TOTP 2FA 的密碼學原理]]></title>
            <link>https://medium.com/starbugs/totp-2fa-algorithm-in-10-mins-25acc3c35df9?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/25acc3c35df9</guid>
            <category><![CDATA[starbugs]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[cryptography]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Sun, 12 Jun 2022 09:57:14 GMT</pubDate>
            <atom:updated>2022-06-12T17:05:20.666Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/758/1*yoNwguVt8V_tQOeEsr5KKQ.png" /><figcaption>image from Twilio</figcaption></figure><p>身為一個工程師，為了提高安全性，應該都會幫自己還有公司的帳號啟用 <strong>2FA</strong>（<strong>T</strong>wo-<strong>F</strong>actor <strong>A</strong>uthentication），不然帳號被盜是真的會出大事。</p><p>像去年就有一個案例是，npm 上有一個超熱門的 package 叫 <a href="https://www.npmjs.com/package/ua-parser-js">UAParser.js</a> 用來解析 User Agent 是什麼瀏覽器，每個禮拜的下載次數都接近一千萬。但去年作者的帳號被盜了之後，駭客在 npm 上發佈了好幾個含有挖礦程式的版本，造成不小的轟動，還好很快就發現了並且把那些版本撤銷掉。</p><p><a href="https://www.ithome.com.tw/news/147450">熱門Npm套件UAParser.js遭植入惡意程式</a></p><p>所以說密碼真的要保管好，而且重要的服務像 Github、Google、Facebook 的帳號最好都上 2FA，才不會 Facebook 被盜，連帶用 Facebook 登入的 Instagram、蝦皮也被盜，那處理起來就真的很麻煩</p><h3><strong>T</strong>wo-<strong>F</strong>actor <strong>A</strong>uthentication</h3><p>今天的主題是 <strong>2FA</strong>（<strong>T</strong>wo-<strong>F</strong>actor <strong>A</strong>uthentication）。這邊簡單介紹一下 ，一般來說我們都是使用帳號密碼來驗證身份，而 2FA 就是<strong>建立除了帳號密碼之外的第二個關卡</strong>。就算帳密不小心外洩了，也不至於馬上被盜用（但還是要定期改密碼啦XD）。而 2FA 又可以分成硬體跟軟體兩種形式</p><h4>硬體型 2FA</h4><p>像在 App Store 上買 App 時需要<strong>指紋辨識</strong>，或是前陣子很紅的 YubiKey，只有把那隻隨身碟帶在身上才能通過驗證，都算是硬體型的 2FA。</p><h4>軟體型 2FA</h4><p>而今天要講的 <strong>OTP</strong>（<strong>O</strong>ne-<strong>T</strong>ime <strong>P</strong>assword） 就是軟體型的 2FA。像大部分銀行在 App 轉帳時都會要求你輸入<strong>「簡訊驗證碼</strong>」、或是當你要從新電腦登入 Google 時，也會需要到手機上打開 Gmail 看驗證碼，這些都算是。</p><p>因為這些驗證碼每次都不一樣，所以我們把它稱為 One-Time 也就是一次性的 Password，每次都不一樣自然安全性也比較高。</p><blockquote>所以像這樣用手機收簡訊驗證碼有什麼不好嗎？</blockquote><p>雖然簡訊驗證碼每次都是隨機的，但其實<strong>簡訊在傳輸的過程中非常不安全</strong>。撇開簡訊不談，就算驗證碼是用 App、電子郵件來傳輸，<strong>只要每次你登入時，服務提供者試圖把驗證碼「傳」給你</strong>，那就有遭竊的可能。</p><p><a href="https://www.ithome.com.tw/news/112845">透過簡訊執行二次驗證不再安全，美國國家標準技術研究所建議別再使用</a></p><blockquote>ㄜ⋯⋯如果我登入時對方不把驗證碼「傳」給我，那我要怎麽拿到驗證碼？</blockquote><p>雖然聽起來很神奇，但確實是可以靠密碼學做到的哦，那就是今天要介紹的主角 TOTP</p><h3>Time-based One Time Password</h3><p>TOTP 的全名是 <strong>T</strong>ime-based <strong>O</strong>ne <strong>T</strong>ime <strong>P</strong>assword，看名字就知道他也是 OTP 的一種，只不過是藉由<strong>目前的時間</strong>來生出 OTP，因此天生就具有隨機性。因為直接看公式太硬了，這邊我用 Github 2FA 的例子來講解他的運作原理</p><p>如果你的 Github 還沒啟用 2FA 的話，可以跟著官方文件先設定好，等等看下面的講解才知道每個步驟在做什麼哦～</p><p><a href="https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication">Configuring two-factor authentication - GitHub Docs</a></p><h4>Step 1 — Server 生成帶有 secret key 的 QRCode</h4><p>通常要啟用 TOTP 2FA 的第一步，都會讓你掃一個大大的 QRCode，而<strong>這個 QRCode 中就帶有 server 想要傳給你的 secret key</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0l4jorZy9SGLSYDrEQT61w.png" /></figure><p>如果把上圖的 QRCode decode 出來會得到 otpauth://totp/GitHub:LarryLuTW?secret=X5CTBOMEYE3TXIIS 這一串鬼東西，意思是這串 URI 是由 Github 發行的，而後面的 secret=X5CTBOMEYE3TXIIS 就是 Github 想要傳給你的 secret key</p><p>因此當你用手機上的 Authentication App 去掃描時（我是用 Authy，<a href="https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication#configuring-two-factor-authentication-using-a-totp-mobile-app">還有很多其他 App 可以選</a>），App 就會把這串 secret 存起來，以後就用這個 secret 生成 TOTP</p><h4>Step 2 — 驗證兩邊生成相同的 TOTP</h4><p>有了這串 secret 之後 App 要怎麼生出下面六碼 OTP 呢？答案就是把 <strong>secret</strong> 跟 <strong>現在時間 </strong>拿去做<strong>雜湊</strong>，然後取最後的六碼作為 OTP</p><blockquote>如果不知道雜湊是什麼，可以先去看看我另外一篇「<a href="https://medium.com/starbugs/what-are-encoding-encrypt-and-hashing-4b03d40e7b0c">一次搞懂密碼學中的三兄弟</a>」，再回來讀會比較順哦</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*vnhurwCa-7KwMZP-cOu9dQ.png" /></figure><p>譬如說我現在時間換算成 <a href="https://www.unixtimestamp.com/">UNIX timestamp</a> 是 1654994758（也就是從 1970 年 1 月 1 號，已經過了這麼多秒），然後 secret 是 X5CTBOMEYE3TXIIS</p><p>因為 App 希望<strong>每 30 秒產生出不同的 OTP</strong>，所以他會把 timestamp/30 的整數部分跟 X5CTBOMEYE3TXIIS 這兩個東西丟進去 <a href="https://zh.wikipedia.org/wiki/HMAC">HMAC</a> 做雜湊，<strong>雜湊的結果轉成十進位取最後六碼</strong>，就可以得到這 30 秒的 OTP 是 017201 了～</p><p>而 30 秒後因為 timestamp/30 的結果又不一樣了，<strong>所以又會生出完全不同的 OTP</strong>（只要輸入值稍有不同，hash 的結果就會完全不一樣）</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3PBile-PM1LYrcZZlJLDCw.png" /></figure><p>有了這六位數 OTP 後，你就在三十秒內到網站輸入 017201（三十秒後又是不同的 OTP）。<strong>如果 Github 那邊剛好也算出跟你一模一樣的結果，那他就知道你已經拿到正確 secret key</strong>。從此之後你跟 Github 就算是約定好 secret 了，Github 也會把這 secret 存在他們自家的資料庫裡面，</p><h4>Step 3 — 登入時驗證 TOTP</h4><p>設定好 2FA 後，以後你要登入時，Github 就會請你輸入 App 生出來的 OTP</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*lslLKcfd508f2qTHY7F7yA.png" /></figure><p>因為雙方已經溝通好 secret 是 X5CTBOMEYE3TXIIS 了，這時你用不著收簡訊，甚至可以不需要網路，<strong>只要把 App 打開它就會幫你算出新的 OTP</strong></p><p>而 Github 收到你輸入的 OTP 後，如果他那邊也算出一樣的結果，那就代表你是本人。如此一來，就實現了「<strong>每次登入時 Github 不用傳驗證碼給你，但你卻可以知道驗證碼</strong>」</p><h3>安全性分析</h3><p>總歸來說，使用 TOTP 來進行 2FA 的第一步就是藉由 QRCode 讓 Server 跟 Client（也就是 App）約定好一個 secret，之後就都用那個 secret 跟當下時間來進行 Hash。我們就按這個流程來評估每個步驟的安全性</p><h4>secret 的傳輸安全嗎？</h4><p>一開始要設定 TOTP 2FA 時 Github 會生出一個 QRCode 讓你掃，<strong>其中就帶有他想要給你的 secret key。</strong>如果這個 secret 在傳輸的過程中一不小心被駭客偷走，<strong>那他日後就可以用這個 secret 生出登入所需的 OTP</strong></p><p>因此在設定 TOTP 時一定要記得檢查網站<strong>是否有 HTTPS 或是憑證過期的問題</strong>，或是看看<strong>有沒有人在你背後偷掃你的 QRCode</strong>。如果都沒有，那恭喜你！世界上應該只有你跟 Github 知道這組 secret，因此非常的安全</p><h4>放 secret 的地方安全嗎？</h4><p>App 收到 secret key 幫你存起來後，<strong>接下來要考慮的就是 App 安全嗎？</strong>譬如說他會不會偷偷把你的 secret 拿去賣錢，或是他有沒有支援雲端備份的功能，一不小心就會外洩出去。</p><p>像我自己用的 Authy 就有支援雲端備份，但我是不怕 secret 不見，也不太擔心手機突然爆掉，所以就沒有啟用。大家可以根據自己的情況去評估看看</p><h4>OTP 會不會被猜到</h4><p>如果駭客拿不到 secret，那他能不能暴力破解猜到六位數的 OTP 呢？這邊簡單試算一下：因為 OTP 有六位數所以有 <strong>一百萬</strong> 種可能性，而且每 30 秒就換一個。如果你想要在 30 秒內猜出來，那每秒就需要進行超過 <strong>三萬</strong> 次登入</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/476/1*6EpD3oWMoGIuvzgZlalqtQ.png" /></figure><p>但實際上<strong>只要連續失敗個幾次，Github 就會暫時把你擋下來</strong>（其他網站也是），而你下次要試的時候驗證碼又不一樣了，所以完全不可能暴力破解</p><p>因此總的來說，<strong>除非你的 secret key 一開始就被偷走，不然使用 TOTP 來做 2FA 絕對是足夠安全的</strong></p><h3>總結</h3><p>好久沒有寫密碼學相關的東西了。這次介紹的 TOTP 2FA 除了<strong>原理簡單、安全性高</strong>之外，我個人覺得最方便的就是 TOTP 是在我手機上產生的、打開 App 就能看到，所以終於不會再收不到簡訊了XDD</p><p>尤其我之前住在台北市的邊陲地帶，簡訊要重送個兩三次才會送到，有時候甚至會一次來兩則，害我一不小心又輸入錯，拜託我只是想登入而已啊！！是有這麼困難嗎？</p><p>至於要用哪個 App，我個人是覺得 Authy 不錯，不過大家也可以看看 <a href="https://www.cloudwards.net/best-2fa-apps/">The Best 2FA Apps 2022</a> 評估一下，選一款最適合自己的～</p><h4>延伸閱讀</h4><ul><li><a href="https://soshace.com/implementing-two-factor-authentication-with-nodejs-and-otplib/">Implementing Two-Factor Authentication with NodeJS</a></li><li><a href="https://medium.com/starbugs/how-to-store-password-in-database-sefely-6b20f48def92">聽說不能用明文存密碼，那到底該怎麼存？</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25acc3c35df9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/totp-2fa-algorithm-in-10-mins-25acc3c35df9">只要十分鐘，帶你看懂 TOTP 2FA 的密碼學原理</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MongoDB explain 實戰— 看看你的 index 是真有在做事，還是佔空間而已]]></title>
            <link>https://medium.com/starbugs/optimize-index-with-mongodb-explain-2337ef50a601?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/2337ef50a601</guid>
            <category><![CDATA[starbugs]]></category>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[indexing]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Fri, 13 May 2022 08:35:29 GMT</pubDate>
            <atom:updated>2022-05-16T08:15:58.755Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H4v8Dq6dfPVrFQRzFRDp8w.png" /></figure><p>在使用 MongoDB 時，如果完全沒有幫 collection 建立 index，那在搜尋時就會需要把整個 collection 翻過來一個一個找過。</p><p>就像你到小北百貨想要買一個「鍵盤」、一個「滑鼠」，如果店家沒有幫你分類成「電腦週邊」、「水電材料」、「衛浴用品」幾大類，加上鍵盤跟滑鼠也不見得放在一起，那可能要<strong>逛完一整圈才能找到你要的東西</strong>。是還好逛一圈小百百貨也沒多久，偶爾去逛一下還能發現一些便宜的好物XD。</p><p>但資料庫就不一樣了，尤其大數據的時代，連小公司都有幾百萬筆的資料。這時如果還一個一個慢慢找簡直就是曠日費時，因此怎麼讓 DB 吃到 index 是一件非常重要的事。</p><h4>圖解 Index</h4><p>在講 explain 之前先來説說 index 大概長成什麼樣子。假如果你今天開一間五金行，要用資料庫來記錄各個商品的庫存（inventory）狀況，那你的 collection 裡面就會有鍵盤、滑鼠、電風扇等等商品的價格跟數量</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KGIaMMKQb_2k36jJytCmdQ.png" /></figure><p>這時如果根據價格幫他們建 index，讓商品從最便宜排到最貴，<strong>那 MongoDB 並不會去修改資料在硬碟中的位置</strong>，而是會另外建一個 price 排序過後的清單並用指標指向資料位置。如此一來，當你想要找價格 699 元的東西時，Mongo 就會很快的從那個清單來找，再藉由指標拿到真實資料</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H4v8Dq6dfPVrFQRzFRDp8w.png" /></figure><p>因為 index 只是另外建一個清單，所以想在同一個 collection 內建多個 index 也是沒問題的唷！譬如說我可以同時幫 price 跟 quantity 建 index，這樣在根據價格或數量做 query 時就都有 index 可以用</p><h3>認識 explain</h3><p>既然加 index 可以加速 query，那是不是拼命幫各個欄位加 index 就好？也不是這樣，<strong>重點在於你加的 index 有沒有被 query planner 吃到</strong>。加了太多沒路用的 index 只不過是佔空間，而且還會拖慢寫入的速度。</p><blockquote>我這邊有準備一個 <a href="https://github.com/LarryLuTW/mongo-explain-demo">mongo-explain-demo</a>，裡面已經塞了一千筆資料，只要跟著 README 用 Docker 跑起來就可以一起玩 explain 囉（我很少這麼認真寫 README 拜託大家去跑一下XD）</blockquote><p>先來看看完全沒 index 的情況下，如果想找到價錢 699 的商品，Mongo 會怎麼做搜尋。方法很簡單，只要在 find({ price:699 }) 後面加上 explain() 就可以了（跑出來會有一大串，我們先看其中的 queryPlanner.winningPlan）</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yCycs7rAJ8yyKHzs4jU3ag.png" /></figure><p>這邊有個關鍵 stage: &#39;COLLSCAN&#39;，<strong>意思是這次 query 是把整個 collection 都找（scan）過一遍</strong>，可想而知效率一定非常的差。</p><p>如果想看更詳細的執行情況的話，可以帶參數 explain(&quot;executionStats&quot;)，就可以看到這次 query 的過程總共檢查了 1000 筆資料（就全部啦XD），最後符合條件的資料卻只有 1 筆，好像很可憐</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xaLHqEnrlpqqRnH713Rerw.png" /></figure><h4>加上 index</h4><p>那要怎麼解決命中率只有千分之一的窘境呢，那就是加一個 { price: 1 } index，意思是建一個 index，讓他根據 price 從小排到大</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ho7iZ7cMKUycd4N27CIZ9A.png" /></figure><p>有了 index 後馬上來看看 explain，果然從 COLLSCAN 變成 IXSCAN+FETCH 了<strong>。注意當有多個步驟（stage）時要從內層往外看，所以是先做 </strong><strong>IXSCAN 再做 </strong><strong>FETCH</strong>，意思是先從 price_1 index 中找到 699（Index Scan），再去把那些資料抓出來（Fetch）。因此我們剛新增的 price_1 是有幫助的。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8KVQd78Z5YsLZD85OmB23A.png" /></figure><h3>Mongo 是怎麼選擇 query plan 的呢？</h3><p>到這邊應該都對 explain 有點概念了，接著來講一個比較複雜的例子，看 Mongo 在多個 index 時，是怎麼選擇「他所認為的最佳的 query plain」</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oSkEgLqTfQKUao5sC2BoRg.png" /></figure><p>現在 price 跟 quantity 欄位上都有 index。先用腦袋瓜想一下，如果我今天想要補庫存，要找「庫存量只剩一個，且價錢低於一萬的商品」，那怎麼使用 index 來找會最快呢？這邊有兩個方案：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qkHr4Q9vIl1CUkEANX3bbA.png" /></figure><p><strong><em>方案一</em></strong>：先利用 quantity index 快速找到 quantity == 1 的那些商品（假設有 200 個好了），再從 200 個中一個一個檢查，找出 price &lt; 10000 的商品</p><p><strong><em>方案二</em></strong>：先利用 price index 快速找到 price &lt; 10000 的商品（只是家五金行，一萬塊以下的商品會超多，所以假設有 800 個），再從 800 個中一個一個檢查，找出 quantity == 1 的商品</p><p>比較一下，<strong>方案一</strong>光是第一步的 quantity == 1 就可以篩選掉不少資料，再從中找 price &lt; 10000 應該很快，<strong>CPU 總共只需要做 200 多次比較</strong>；而<strong>方案二</strong>的第一步 price &lt; 10000 可以篩選掉的資料很少，<strong>加上第二步可能要做 800 多次的比較</strong>。<strong>所以沒意外的話應該是方案一比較好</strong></p><p>但這畢竟是我們人工判斷的結果，<strong>之所以能這樣判斷是因為我們知道這是一家五金行的資料、也知道他的資料特性（一萬塊以下的商品會超多）</strong>。但對資料庫而言裡面就只是一堆資料，所以 MongoDB 自己有一套方法來選出最佳方案。</p><h4>不知道哪個方法快？那就跑跑看吧！</h4><p>對 MongoDB 而言，因為不知道裡面的資料長什麼樣子，所以<strong>他會直接把各個可能的 plan 都試跑一下，看哪個 plan 最先回傳 101 筆結果，就會被選出來當 winning plan</strong></p><p>以這個例子來說，我們可以用 explain(&quot;allPlansExecution&quot;) 來看各個 plan 執行的狀況（因為<a href="https://gist.github.com/LarryLuTW/fc6cf26f637d3cab21716d3edcce96ab">噴出來的結果</a>太詳細了，直接給大家看重點）</p><p>從下圖可以看到當方案一（先用 quantity index）抓到前 101 筆資料時，方案二（先用 price index ）才剛抓到 15 筆資料而已，所以正如我們預期的，方案一確實比方案二快上許多</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SGhVN4HY6avVwkdEH2XXvA.png" /></figure><p>而 MongoDB 其實也不會每次都做方案之間的比較，他只要比過一次就會把結果 cache 起來，避免每次 query 都浪費在做一樣的事情。</p><p>所以如果你在 production 上加了 index 之後 MongoDB 沒有馬上使用新的 index，那也不代表他不好，只是可能要過個幾天才會被 MongoDB 用上</p><h4>強迫推銷 index</h4><p>雖然 MongoDB 大部分情況下都會選擇最佳方案，但在極少數的情況下也可能會選錯。所以如果你加了一個你覺得<strong>「超級好用、一定要用、不用會出大事</strong>」的 index，但 MongoDB 卻遲遲沒有用上，那就可以用 hint(index) 來強迫推銷 MongoDB 一定要使用你的 index</p><p>以剛剛的例子來說，MongoDB 認為最佳方案是優先使用 quantity_1，跑出來的結果是：總共需要檢查 148 個 document 才能得到結果</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*78xoFSHKUb65QUCarg95Ww.png" /></figure><p>但如果我覺得 price_1 才是真正對他好的 index，那就可以在 query 時加上 hint(&quot;price_1&quot;) 提醒（強迫）他用這個 index 來做搜尋，然後看看結果是不是跟你想的一樣好。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BqhYMYseh1xTjogXKYMeeQ.png" /></figure><p>以這個例子來說，強迫他使用 price_1 的結果就是 totalDocsExamined 從 148 變成 988，速度直接慢了好幾倍，一點幫助都沒有 😢😢😢</p><h3>總結</h3><p>到這邊大家對於 explain 的使用方式都有些概念了，透過 explain，你可以不斷檢驗 index 是不是真的適合你的應用，避免自己加了一堆「感覺有用」的 index，但其實只是多佔空間而已。</p><p>受限於篇幅，今天講到的 index 都是針對某個欄位的 <a href="https://www.mongodb.com/docs/manual/core/index-single/">Single Field Index</a> 而已，之後有機會再來講怎麼針對各種應用場景，客製化最適合的 <a href="https://www.mongodb.com/docs/manual/core/index-compound/">Compound Index</a> 及 <a href="https://www.mongodb.com/docs/manual/core/index-partial/">Partial Index</a>，讓你 query 的速度更上一層樓～</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2337ef50a601" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/optimize-index-with-mongodb-explain-2337ef50a601">MongoDB explain 實戰— 看看你的 index 是真有在做事，還是佔空間而已</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[究竟，怎麼樣才能算是「資深」工程師？]]></title>
            <link>https://medium.com/starbugs/how-to-be-a-senior-engineer-c64cf236c8e9?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/c64cf236c8e9</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[starbugs]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Sun, 28 Nov 2021 10:14:58 GMT</pubDate>
            <atom:updated>2021-11-29T09:03:00.118Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fBXl9v9jvbTGGX7Hz4v6yA.png" /></figure><p>前幾天看到老莫寫的「<a href="https://oldmo860617.medium.com/%E6%88%90%E7%82%BA-software-engineer-%E5%8D%8A%E5%B9%B4%E5%BE%8C%E7%9A%84%E5%B0%8F%E5%9B%9E%E9%A1%A7-%E6%88%91%E9%81%87%E5%88%B0%E7%9A%84%E5%9B%B0%E9%9B%A3%E8%88%87%E5%8F%8D%E6%80%9D-f14e8349f6de">成為 Software Engineer 半年後的小回顧 — 我遇到的困難與反思</a>」，想到自己加入現在的公司也好一陣子了。雖然我的職稱是資深工程師，但老實說最近跟前輩一起開發專案後才發現自己根本就還不夠「資深」XD，尤其是在軟實力以及軟體工程方面都還有很多進步的空間。</p><p>所以趁這個機會，我想跟大家聊聊我身邊的「真．資深工程師」大概都具備怎麼樣的能力跟特質，以及身為普通的工程師，應該要朝什麼方向去努力。</p><h3>實作能力</h3><p>既然是工程師，不管你是上班時做公司專案，還是下班後自己搞 Side Project，<strong>最重要的任務就是把腦中的構想透過寫程式實現出來</strong>，所以實作的能力絕對是必要的。就像 Linus Torvalds 的名言「Talk is cheap. Show me the code」，光說是沒有用的，只有把程式碼寫出來了，那才算是真正完成了一件事情。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vaZ38uKOSSPl8NdSzOJh4A.png" /></figure><p>實作能力要到什麼程度才能算是「資深」呢？這也沒有標準答案，但根據我的觀察，資深工程師們的實戰經驗往往非常豐富，只要你的需求不要太過嚴苛（希望系統的可用性有十個 9 之類的XD），<strong>幾乎沒有做不出來的東西</strong>。</p><p>任何 ticket 對他們來說大概都只有「這個簡單弄一下很快就好了」跟「這東西我要花點時間研究一下」兩種，而且他們通常都可以<strong>獨立作業</strong>，不會突然跑來問你「為什麼我的 npm install 跑不過」、「我沒寫過 Dockerfile 可以教我嗎？」。</p><blockquote>說了這麼多，那實作能力要怎麼練起來呢？</blockquote><p>關於這個問題，我的想法是要不斷學習新東西，並且真的應用在實戰中。</p><p>譬如我原本就很熟悉用 Node.js 寫 Restful API，那下次 Side Project 就可以試試 GraphQL 或是乾脆改用 Rust，雖然第一次寫 Rust 會被編譯器搞得很痛苦（想把電腦砸爛的那種），但寫了就會發現「原來這種地方可能會有 data race！」、「原來非同步不是只有 callback 跟 promise 兩種處理方法」，<strong>而這些事情做久了會慢慢提升你的技術深度跟廣度</strong>。</p><p>有了足夠的技術深度跟廣度之後，<strong>既便未來遇到一些沒碰過的東西，也只需要花個五到十分鐘就能看懂他在幹嘛</strong>，甚至能猜到底層的技術原理，因此有需求進來時即便不熟悉也可以更有把握的把東西寫出來。</p><h3>願意花時間做設計</h3><p>雖然資深工程師很懂怎麼寫程式，<strong>但除了寫程式，我認為他們最厲害的地方其實是設計</strong>。這邊的「設計」指的不是 UI 上的設計，而是在真正開始動工之前的「系統設計」以及「技術選型」。</p><p>我身邊很多資深工程師在工作時<strong>並不花太多時間寫扣</strong>，因為對他們而言「事前設計」的重要性遠大於「實作」，<strong>錯誤的設計一但開始動工了，可能要花費設計階段所需的十倍甚至百倍時間來彌補。</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uHEr_RC-Yllqoh2iU0azOw.png" /></figure><p>就像我前陣子在幫忙公司的一個專案，那個專案最初是從 2016 開始的，也就是 Python 3.6 發佈那一年，但專案竟然是選擇用已經被官方放棄的 Python 2 來開發，導致後來很多套件都無法更新，整個專案也無法維護，只好重新寫一個版本。</p><p>因此在真的開始實作之前，好的資深工程師們會先仔細確認需求、設計資料庫 Schema、思考後端架構等等，等這些大方向都確定下來之後，才是開始寫下第一行程式碼，這種「先確定大方向，再慢慢完成小細節」的工作方式讓我非常欣賞。</p><blockquote>要怎麼增強系統設計的能力呢？</blockquote><p>系統設計這方面其實我也還算是新手，所以沒辦法給出一個很明確的答案，大家參考參考就好。我認為想要把系統設計做好，除了自己要有一定的技術深度及廣度之外，<strong>最重要的就是跟其他人討論</strong>，不然很容易受限於自己過去的經驗，而想不到更好的方法。</p><p>譬如說我多年前剛開始做 Side Project 時，都是用 <a href="https://aws.amazon.com/tw/ec2/">AWS EC2</a> 開機器來跑 API server。<strong>因為那時不知道有 </strong><a href="https://aws.amazon.com/tw/s3/"><strong>S3</strong></a><strong> 這種服務可以放靜態檔案</strong>，所以 server 收到的資料都是直接放在機器上。而這樣做的代價就是我的服務<strong>沒辦法水平擴展</strong>，如果效能不夠就只能升級到更好的機器，現在回頭看真的很傻很天真XD。</p><p>因此我覺得在對於架構的掌握夠全面之前，盡量還是要多跟別人討論，真的沒人討論的話也可以多看一些文章跟書，像我前陣子看到「<a href="https://medium.com/%E5%BE%8C%E7%AB%AF%E6%96%B0%E6%89%8B%E6%9D%91/backend-architecture-101-5c425e760a13">系統設計101 — 大型系統的演進</a>」跟「<a href="https://github.com/donnemartin/system-design-primer/blob/master/README-zh-TW.md">系統設計入門</a>」都很不錯，有很多東西用講的很模糊但圖一看就懂了。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/985/1*tZfzi01ezR-wl2MnP22Krw.png" /></figure><p><strong>而這些知識都備齊後就是靠實戰累積經驗了</strong>，只要每次開發新功能之前都有認真做設計，那必定可以感受到每一種設計在<strong>開發速度、部署流程、可擴展性</strong>等等各方面的好壞，久而久之設計出來的系統也就會越來越完整。</p><h3>團隊先於個人</h3><p>這點是我從其他「真．資深工程師」身上觀察到最令人敬佩的地方，<strong>好的資深工程師會去思考怎麼提升整個團隊的效率，而不只是個人的績效。</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uud3XDpaw3rl_oVGQQmeEQ.png" /></figure><p>以寫文件這件事來說，每家公司都會有自己的開發流程、部署流程、AWS 密碼放哪之類的。而我身邊的資深工程師就很樂意把這些東西整理成文件，畢竟如果沒有文件到時也是去問他XD，所以先花點時間寫起來不只省了自己時間、也省整個團隊的時間。</p><p>另外，他們也很願意寫自動化測試，當然測試不可能全部都測，但如果能把系統中絕對不能壞的地方用測試保護，那團隊內其他同事在開發時就可以更安心，而且也不會有人假日還要被挖起來修 bug XD。</p><p>除了寫文件及測試之外，在技術選型方面，他們也是以整個團隊為優先，認真考量各個技術的效益跟學習曲線。</p><p>比方說因為 Docker 很好學，花一個下午就可以學會寫 Dockerfile 了，所以用它來做部署的 CP 值就非常高；但如果說是要用 Rust 來寫 API Server，雖然可以提高效能幫公司省開機器的錢，但一來團隊內的新人要花更多時間才能上手、二來要找到會寫 Rust 的工程師真的不容易，所以顯然不是一個好的方案。</p><blockquote>還有什麼要做什麼的嗎？</blockquote><p>雖然「以團隊為優先」聽起來很抽象，但其實做起來並不難，只要你抱持著推己及人的心態，在做任何事情的時候都想一下「別人會不會也有相同的困擾？」，然後花點時間幫忙解決，那離資深工程師也就不遠了</p><h3>總結</h3><p>要成為資深工程師，絕對不是年資到了或是 Leetcode 刷得夠多就可以。好的資深工程師除了技術能力夠扎實之外，在溝通能力以及心態上也必須足夠成熟（這方面我也還在努力），才有辦法帶領整個團隊一起前進。</p><p>以上就是我從自己身邊觀察到的資深工程師，當然資深工程師還有很多種樣子，而且他們有些還會有自己的特異功能（特別會通靈、隔空解 bug 之類的XD），因此大家有空也可以多觀察身邊的前輩們到底厲害在哪裡，也許能從他們身上學到不少東西哦～</p><h4>延伸閱讀</h4><ul><li><a href="https://blog.techbridge.cc/2016/12/31/review-2016/">一個資淺工程師年末的自我省視</a></li><li><a href="https://jaceju.net/be-a-senior-engineer/">如何才有資格稱為資深工程師</a></li><li><a href="https://coolshell.cn/articles/17583.html">技术人员的发展之路</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c64cf236c8e9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/how-to-be-a-senior-engineer-c64cf236c8e9">究竟，怎麼樣才能算是「資深」工程師？</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[從 map 的實作聊聊為什麼 Go 需要有泛型]]></title>
            <link>https://medium.com/starbugs/why-go-need-generics-c8f1495ef00a?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8f1495ef00a</guid>
            <category><![CDATA[go]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[starbugs]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Sun, 31 Oct 2021 13:10:40 GMT</pubDate>
            <atom:updated>2021-11-02T00:44:50.551Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AZVF6uHda7zRyWMN1j84Dg.jpeg" /></figure><h3>前言</h3><blockquote>這篇的程式碼比較多一點，手機可以存起來用電腦看比較好讀哦～</blockquote><p>關於 Go 到底要不要支援泛型、以及泛型的語法該怎麼設計已經討論好久了（大概十年有吧XD），近幾年來官方也不斷修改泛型的<a href="https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md">設計草案</a>，總算是在去年把泛型語法定下來，<strong>也承諾要在 Go 的下個版本 1.18 中正式支援泛型</strong></p><p>那究竟為什麼需要泛型呢？現在的 Go 就算沒有泛型，不是照樣寫出 <a href="https://github.com/moby/moby">Docker</a>、<a href="https://github.com/kubernetes/kubernetes">Kubernetes</a>、<a href="https://github.com/hashicorp/terraform">Terraform</a> 這些超厲害的東西嗎？</p><p>所以今天就是想跟大家說說泛型到底解決了 Go 的哪些問題，也順便讓大家看看 Go 的泛型怎麼寫（非常簡單，看一下就會了），到時候明年 1.18 出來就可以馬上開始用了哦～</p><h3>從 map 開始談起</h3><p>寫過動態語言如 Python、JavaScript 的人應該都很熟悉語言內建的 map function，他讓你可以很輕易的對整個 array 做操作，譬如說整個 array 都乘二之類的。但在 Go 裡面卻沒有內建的 map，因此我們來自己寫一個</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9e1842efd5f3990f2706ef718504b73e/href">https://medium.com/media/9e1842efd5f3990f2706ef718504b73e/href</a></iframe><p>有了寫好的 map function 後，<strong>團隊內的其他成員就可以隨時拿去用，就算不知道 map 內部是怎麼實作的也沒關係</strong>，總之，用就對了</p><p>但如果今天突然來了個新的需求：老闆為了追隨 Elon Musk，希望以後大家的薪水都改用狗狗幣發放，因此要你寫個程式幫公司同仁們的薪水，以 8:1 的比例的換算成狗狗幣，譬如說月薪 40000 那就發給你 5000 顆</p><p>雖然這需求聽起來極度荒謬，但重點是這樣一來我們自己寫的 map function 就派不上用場了，<strong>因為他只能把 </strong><strong>[]int 對應到 </strong><strong>[]int，但狗狗幣的算出來會有小數點</strong>，也就是說我們會需要另一個可以給 []float64 用的 map function</p><h3>Solution 1 — 缺什麼寫什麼</h3><p>正所謂「頭痛醫頭，腳痛醫腳」，現在需要一個給 float 用的 map function，那我就另外寫一個 mapFloat，<strong>反正照抄過去改一下型別就好</strong>，打開 VSCode 十秒鐘就寫出來了</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a03b2620f59f9a084694746828a1298b/href">https://medium.com/media/a03b2620f59f9a084694746828a1298b/href</a></iframe><p>雖然這樣看似解決了問題，但這樣做有兩個非常明顯的缺點：</p><p>一來是<strong>這兩個 map function 的實作邏輯完全一模一樣</strong>，只不過是把接受的參數從 []int 改成 []float64 而已。從軟體工程的觀點來看這樣嚴重違反了 <a href="https://zh.wikipedia.org/wiki/%E4%B8%80%E6%AC%A1%E4%B8%94%E4%BB%85%E4%B8%80%E6%AC%A1"><strong>DRY</strong>(Don’t Repeat Yourself)</a> 原則，如果哪天發現 map function 裡面有地方寫錯了，就又要一次改兩個地方（有時候甚至會發現一個有錯一個沒錯，可能是複製的時候改錯了，那就真的很慘），導致專案的維護成本提高</p><blockquote>雖然 map function 很難寫錯 XD，不過這邊只是舉個例子，實務上很多落落長的 function 都會一再修改，因此有兩個功能一樣的 function 就會非常麻煩</blockquote><p>二來是這樣並沒有解決根本問題，如果哪天新的需求又來了：「老闆為了展現他對加密貨幣的決心，突然決定把公司名字改叫 crypto，所以要你寫個程式把大家的信箱從 [Luka@abc.com, Andy@abc.com] 改成 [Luka@crypto.com, Andy@crypto.com]」，那就還要寫一個給 string 專用的 map function，這樣一直加新的 map function 也不是辦法</p><h3>Solution 2 — 通用的 map function？</h3><p>因為一直寫重複的程式碼實在是太糟糕了，<strong>有沒有什麼方法可以寫出一個同時支援 int 跟 float64 的 map function 呢？</strong>於是你去查了一下發現很多人是用 interface{} 來解的</p><p><strong>因為在 Go 裡面任何變數都可以轉成 </strong><strong>interface{} 型別</strong>，所以只要把 map function 的參數型別改成接受 []{}interface（看起來很複雜，但其實就是 array of interface{}），那就可以實作出一個通用版本的 map function</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7b6d58b33c2892a40a09ee8a4e7cf13f/href">https://medium.com/media/7b6d58b33c2892a40a09ee8a4e7cf13f/href</a></iframe><p>雖然這個 map 看起來非常通用（整個函數簽名有四個 interface{} XD），但其實用起來非常很麻煩。如果你現在手上已經有一個 int array，<strong>那你要先把它轉成 </strong><strong>interface{} array，接著才能丟進去 Map 裡面做 map</strong>，寫完自己看很可能都看不太懂</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0a495bbf0d26720c8ed413ed2b48fb2a/href">https://medium.com/media/0a495bbf0d26720c8ed413ed2b48fb2a/href</a></iframe><p>而通用性方面，雖然這個版本真的有比較通用，而且整份 codebase 裡面也不會有多個 map function，但整體而言還是非常不知道在幹嘛，光是看到那堆 interface{} 頭就痛了，要我用這個的 map function 我寧願自己用 for loop 把 array 跑過一遍就好</p><p>而且除了麻煩之外，「<strong>型別轉換、確認」這些該由編譯器做的事情現在被拿到 runtime 來做</strong>（我寫的不是靜態語言嗎？），所以效能不用說當然是會慢非常多，所以這種做法雖然通用但也是被很多人嫌棄</p><h3>Solution — Type Parameter</h3><p>但 Go 身為新一代的靜態語言，如果想要走在潮流的尖端，總不能連簡單的 map 都寫不出來吧？因此 Go 決定從 1.18 起開始支援 Type Parameter，讓你在宣告一個 function 時，可以不用太過在乎參數的型別，就像你在寫 JS 時一樣</p><p>而 Type Parameter 的寫法就像這樣：你在宣告 Map 時可以先說「<strong>我假設有一個型別叫做 T，這個 T 可以是任何（any）型別</strong>」，接著後面就可以把 T 當成已經存在的型別來使用</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e6df33a6c3adcc0505f815f6a01a751d/href">https://medium.com/media/e6df33a6c3adcc0505f815f6a01a751d/href</a></iframe><p>如果仔細跟之前寫的 MapFloat 比較一下的話，就會發現 Type Parameter 其實就是在函數名之後加上 [T any]，然後把後面的 float64 都改成 T 而已</p><p>那要使用這個泛型後的 Map[T any] 函數會很麻煩嗎？一點都不會，就直接把他的參數 (arr []T, fn func(T) T) 看成 (arr []int, fn func(int) int) 就好了（其實就是把 T 換成 int 啦XD）</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8b63fdfc45eb400dad09a162bcdec628/href">https://medium.com/media/8b63fdfc45eb400dad09a162bcdec628/href</a></iframe><p><strong>因爲 Go 的編譯器會自動推斷這邊的 T 是什麼，像上面的例子中 T 就分別是 int 跟 float32</strong>，因此你完全不需要多做什麼事，就很像在寫 JS 一樣，使用上完全沒有障礙</p><p>到目前為止，我們這個 map 已經可以用來做任何 []T 到 []T 的 mapping 了，不管那個 T 是 int、float32 還是什麼型別，都可以直接使用這個泛型的 map function</p><h3>更通用的 map function</h3><p>但現在另外一個需求又來了，老闆不知道為什麼，又希望你寫個程式計算一下大家英文名字的字數，因此你會需要輸入 [Larry, Luka, Andy] 陣列、然後輸出 [5, 4, 4]，於是你便這樣寫</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3e201d4ad2bd429537b89987d605afcd/href">https://medium.com/media/3e201d4ad2bd429537b89987d605afcd/href</a></iframe><p>原本以為可以一帆風順，想不到編譯時竟然噴出了錯誤，<strong>因為我們現有的 Map 只能把 </strong><strong>[]T 對應到 </strong><strong>[]T 型別，而且這兩個 T 必須是一樣的</strong>。但我們現在做的事情是把 []string 對應到 []int，所以編譯器當然會噴錯</p><p>為了解決這個問題，我們要把 map 寫得更加通用，讓他可以把 []T1 對應到 []T2，<strong>而且 T1 跟 T2 可以是兩個不一樣的型別</strong>，那要怎麼寫呢？</p><p>首先是把 [T any] 改成 [T1, T2 any]，<strong>代表我們允許有 T1、T2 兩個任意型別</strong>，接著再把後面的輸入改成 []T1、回傳值改成 []T2、還有最重要的 fn 改成 func(T1) T2（輸入 T1 型別，回傳 T2 型別），這樣就大功告成囉</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/602d4d6f19650e0c6252138626abc4c1/href">https://medium.com/media/602d4d6f19650e0c6252138626abc4c1/href</a></iframe><p>實際用的時候也很簡單，因為 Go 編譯器會看到你的輸入型別是 []string，而回傳值型別是 []int，<strong>因此他會知道 T1 是 string、T2 是 int</strong>，執行出來的結果當然也跟我們預期的一樣是 [5 4 4]，<strong>而且這個版本兼具了通用性以及型別的嚴謹度</strong>，自己寫完都覺得很漂亮XD</p><h3>小結</h3><p>自從知道 Go 要以 Type Parameter 的方式支援泛型之後就一直很期待後續的發展，不過也有聽到一些想法覺得加入泛型後會讓 Go 的學習門檻變高，所以還是維持現狀比較好</p><p>但我個人覺得<strong>泛型可以讓邏輯跟型別不必綁在一起</strong>，帶來的效益實在是太大了，而且有了泛型之後可以少寫、少維護很多程式碼，所以才想寫這篇文章讓大家了解為什麼 Go 需要泛型，也希望今天這些講的這些例子可以讓大家覺得 Go 的泛型其實很好學，那我就心滿意足了～</p><p>另外雖然今天講的 map function 例子很簡單，針對不同型別寫好幾個 mapInt、mapFloat、mapString 好像也沒關係，但在實際開發的時候一直 copy/paste 也滿浪費時間的，而且 function 一多又要花時間維護，<strong>所以最好一開始就把 function 寫得足夠通用</strong>（泛型只是其中一種方法），那後面同事要拿去用也會輕鬆很多～</p><p>還有還有，雖然 Go 1.18 要明年才會發佈，但想先玩玩看泛型的話可以把今天的範例貼到 <a href="https://go2goplay.golang.org/p/-PmFqD5vXwp">go2go Playground</a> 跑跑看，是真的可以跑哦～</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8f1495ef00a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/why-go-need-generics-c8f1495ef00a">從 map 的實作聊聊為什麼 Go 需要有泛型</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[幾個小技巧，讓你寫出更安全的 Dockerfile]]></title>
            <link>https://medium.com/starbugs/dockerfile-security-tips-d4161f6450f8?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4161f6450f8</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[starbugs]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Sat, 04 Sep 2021 05:59:39 GMT</pubDate>
            <atom:updated>2021-10-09T01:22:42.467Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AUvtdqYuiLXoKuiV10692w.png" /></figure><p>自從進入大容器時代後，Docker、K8s 已經逐漸成為開發、測試及部署時不可或缺的工具，如果突然叫我不要用 Docker，那我可能什麼都做不了，但也因為這樣，跟容器有關的攻擊越來越普遍，因此容器的安全性也越來越重要</p><p>而<strong>想要從零開始建出一個容器，第一步就是要寫 Dockerfile 把你的應用包裝成 Docker image</strong>。關於怎麼產生出盡量小的 image 已經很多人寫過了，所以今天想要跟大家分享的是想要寫出一個安全的 Dockerfile，有哪些該注意的地方</p><blockquote><em>這篇文主要著重在 Dockerfile 的安全性，所以不會介紹基本語法，若是還沒有寫過 Dockerfile 的話可以先讀完我之前寫的「</em>一步一步帶你 dockerize 你的應用<em>」，再回來繼續往下會比較看得懂哦～</em></blockquote><p><a href="https://larrylu.blog/step-by-step-dockerize-your-app-ecd8940696f4">Docker 實戰系列（一）：一步一步帶你 dockerize 你的應用</a></p><h3>使用 stable 或 LTS 的 base image</h3><p>很多人在寫 Dockerfile 並不會特別指定 base image 的版本（就懶啊，我懂 XD），譬如說想要包一個 Node API server，就直接寫 FROM node 或是 FROM node:latest</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4ef54678d6bd498200a5a1761a49f499/href">https://medium.com/media/4ef54678d6bd498200a5a1761a49f499/href</a></iframe><p>但這樣可能會在哪次 <strong>build image 時就意外從 Node 14 升到 Node 16，導致部分功能直接壞掉</strong>。而且最新版本的 Node 可能有一些不為人知的 bug，需要有一些勇者去幫忙踩坑，所以除非是自己的 Side Project 想要玩玩看最新的 feature，否則<strong>直接把最新版本的 Node 用在 production 並不是個好作法</strong></p><p>比較好的方式是<strong>先看看 Node 的 LTS（Long-Term Support） 版本是多少</strong>，像我在寫文章的當下是 v14.17.5，那就選擇 node:14 或是 node:14.17 作為 base image</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cb09625ba3f2136a27a0fec6a6f938f5/href">https://medium.com/media/cb09625ba3f2136a27a0fec6a6f938f5/href</a></iframe><p>這樣做一來是可以把版號固定在 Node 14、確保不會有大變動，二來是 LTS 的版本都會不斷推出 security fix，因此如果哪天 Node 更新到 v14.17.10，那些 security fix 也會在部署時被加進的 API server，<strong>我們只要坐等更新就好了</strong></p><h3>安裝套件時要指定版本</h3><p>這點跟上面提到的不要用 latest image 有些類似，不管你是用 apt-get install 安裝 CLI 工具、用 npm install 裝函式庫、還是用 curl/wget 把東西下載回來編譯，都要<strong>盡量確保每次下載到的東西是一樣的</strong></p><p>譬如在用 apt-get 安裝 nginx 時就可以透過 apt-get install nginx=1.14.0 來下載指定版本（有點麻煩對吧，我也覺得XD），而 npm、pip 這類的語言套件管理工具則是看官方推薦什麼方法，像 npm 就是用 package-lock.json 來鎖定套件的版本、pip 的話則是先跑 pip freeze &gt; requirements.txt 把套件的版本凍起來，等要安裝時再跑 pip install -r requirements.txt 把原本的套件裝回來</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f327d52738a50b5c98a02fa36e649083/href">https://medium.com/media/f327d52738a50b5c98a02fa36e649083/href</a></iframe><p>雖然把套件版本的鎖定之後可以省下很多麻煩，<strong>但也不能一直鎖在那都不更新，所以記得偶爾去檢查一下版本是不是太舊了</strong>，如果太舊再手動把版號升上去就好了～</p><h3>只 COPY 需要的東西</h3><p>平常在寫 Dockerfile 時，有些人為了一時方便，會直接用 COPY . /app 把整個專案資料夾複製到 container 的 /app 資料夾內。這樣不用動太多腦筋，在 container 裡面也可以直接存取到所有檔案，但這樣的做法可以說是糟透了</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a6901092eb2f50d91c90b6ee8e7a1657/href">https://medium.com/media/a6901092eb2f50d91c90b6ee8e7a1657/href</a></iframe><p>首先是這樣會讓 image 變得很肥（連 node_modules 都進去了能不肥嗎XD），而且一不小心就會把 .envrc 這類敏感資料一起放進去，<strong>如果哪天這個 image 被駭客拿到，裡面的 AWS 憑證、資料庫密碼等等超機密資料就會直接外洩出去</strong>，哪天突然被刪庫也是有可能的</p><p>為了避免這種事情發生，<strong>在 build image 時應該只把需要的東西複製進去</strong>，譬如說你馬上就要跑 npm install，這才把 package.json 跟 package-lock.json 放進去，<strong>而程式碼也是把真的會跑到的那些放進去就好</strong></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/646addf37582bce7e6830f8e9b6deb54/href">https://medium.com/media/646addf37582bce7e6830f8e9b6deb54/href</a></iframe><p>而且這樣還有另外一個好處，就是如果你改了 src 裡面的程式碼，但沒有安裝新的 package（開發時大部分都是這樣吧～），<strong>因為 Docker 會自動做 cache，所以就不需要重新跑一次 npm install</strong>，會直接從第 10 行的 npm run test 開始跑，因此可以大幅縮減需要等待的時間</p><h3>用 multi-stage build 捨棄不需要的檔案</h3><p>這跟上一點有點類似，<strong>簡單來說就是不要留任何不需要的東西在 image 裡面（</strong>沒用的東西都給我滾），即便那是 build image 過程中產生的東西也是一樣</p><p>譬如說原本 Go API server 的 Dockerfile 可能長這樣，因為要在 build image 時編譯出執行檔，所以第 5 行的 COPY *.go 是一定要的，沒有他們就無法進行編譯</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/409ee2a84720bfb76899103dd08ff3a7/href">https://medium.com/media/409ee2a84720bfb76899103dd08ff3a7/href</a></iframe><p><strong>但說真的一旦編譯出執行檔之後，那些 Go 程式碼就用不到了，</strong>所以應該來個爽快的過河拆橋，用 multi-stage build 把編譯完的執行檔保留下來就好，程式碼什麼的就直接拜拜</p><p>像下面這個這個 Dockerfile 經過 multi-stage build 後 image 裡面就只有 /app/main 這個編譯好的執行檔，沒有任何程式碼以及 Go 的編譯器，非常的存粹</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8b0fe41d04c42119bf07332b8c293c18/href">https://medium.com/media/8b0fe41d04c42119bf07332b8c293c18/href</a></iframe><p>那這樣有什麼好處呢？除了 image 可以變小很多之外，<strong>即便 image 被駭客拿到了，程式碼也不會外流出去（有很多攻擊都是拿到程式碼後從裡面找到漏洞）</strong>，因此只保留執行檔可以提高安全性</p><p>除此之外，<strong>因為環境越複雜就越可能有沒發現的漏洞</strong>，而把 base image 從原本的 golang:1.17 換成 Google 提供的 <a href="https://github.com/GoogleContainerTools/distroless">distroless image</a> 剛好可以大幅減少環境的複雜度（distroless 幾乎沒裝什麼東西，連 shell 都沒有），也就可以提高安全性</p><h3>不要把敏感資料 hardcode 在 Dockerfile 裡面</h3><p>我想這已經是常識等級的安全知識了，<strong>因為直接把敏感資料用 </strong><strong>ENV 寫在 Dockerfile 裡會讓駭客輕易拿到</strong>（只要拿到 image 就可以了），所以絕對不要想不開把資料庫或任何的帳號密碼寫在裡面，ENV 頂多用來設定時區或是 NODE_ENV 這種被看光也不會出事的變數就好，不然哪天資料被偷走真的會哭出來</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d854d74653cf495b531f57b63db4b873/href">https://medium.com/media/d854d74653cf495b531f57b63db4b873/href</a></iframe><p>如果說 ENV 不能放敏感資料，那這些資料究竟要怎麼被加進環境變數呢？</p><p>答案就是在 docker run 時加上 --env 或是 --env-file <a href="https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file">把環境變數塞進去</a>；如果是用 docker-compose 的話，則是<a href="https://docs.docker.com/compose/environment-variables/#set-environment-variables-in-containers">把那些資料寫進 </a><a href="https://docs.docker.com/compose/environment-variables/#set-environment-variables-in-containers">docker-compose.yml 的 environment 裡面</a>，<strong>這樣 container 啟動時就會讀到這些變數，而且即便 image 被偷走也不用擔心資料外洩</strong></p><h3>弱點掃描</h3><p>可以做的事情都做了之後，最後就是要來用工具來做弱點掃描了。因為做弱描的工具還滿多的，這邊就介紹已經被 Docker 加進 CLI 的 Snyk，他可以把你的環境、安裝的套件丟到他們資料庫去做搜尋，看有哪些潛在的危險</p><p>譬如說我手邊有幾個多年前用 Node.js 寫的 express server，Dockerfile 長這樣（看到 9.2.0 就知道真的是多年前XD，現在都已經 Node 16 了）</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8d7e3ad871c7075c43a39c2d569612ed/href">https://medium.com/media/8d7e3ad871c7075c43a39c2d569612ed/href</a></iframe><p>先用 docker build . -t app 把 image 建出來後，接著就下 docker scan app 對他做掃描。因為我用的是古早古早以前的 node:9.2.0，所以光 Base Image 的部分掃出來就有 1039 個漏洞，而且其中 99 是屬於 critical 等級的，嚇都嚇死</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FnBbkmBYd8QA6dt0M-tJIA.png" /></figure><p>除了告訴你有多少漏洞之外，他還會把每個漏洞給列出來（有興趣可以去讀一下那些漏洞的報告，其實都不長），並且告訴你那些漏洞分別在哪些版本修掉了</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4I7j2coYVQwWZY6wqUSeFQ.png" /></figure><p>如果懶得看那些漏洞的話，也可以直接滑到最底下看他給你的建議，譬如這邊他就建議把 base image 升級到 node:16.7.0，若是不一定要 full image 的話，那 node:16-bullseye-slim 也是不錯的選項，<strong>因為安裝的東西更少，所以漏洞自然也更少</strong></p><blockquote>Debian bullseye 是今年八月剛發佈的版本，可能比較不穩定</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f3nHZovlPf1kwy0HP1LiqA.png" /></figure><h3>總結</h3><p>今天介紹了一些在寫 Dockerfile 時的注意事項，雖然很多都是小地方，但畢竟魔鬼藏在細節裡，想要讓你的 Docker image 更安全，那就連這些小細節都不能放過</p><p>最後順便宣傳一下，如果對其他資安的東西有興趣，我今年參加鐵人賽的主題是「<a href="https://ithelp.ithome.com.tw/users/20107714/ironman/4279">從以卵擊石到堅若磐石之 Web API 安全性全攻略</a>」，而除了我之外，我們 Starbugs 團隊的其他人也有報名 Web 跟 DevOps 相關的主題，快趁現在到 <a href="https://ithelp.ithome.com.tw/2021ironman/signup/team/176">StarBugs 團隊頁面</a> 訂閱一下，才不會錯過我們寫的文章哦～</p><h4>延伸閱讀</h4><ul><li><a href="https://aquasecurity.github.io/trivy/">Trivy Introduction</a></li><li><a href="https://cheatsheetseries.owasp.org/cheatsheets/Docker_Security_Cheat_Sheet.html">Docker Security Cheat Sheet</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4161f6450f8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/dockerfile-security-tips-d4161f6450f8">幾個小技巧，讓你寫出更安全的 Dockerfile</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[你不能不知道的安全性 HTTP headers]]></title>
            <link>https://medium.com/starbugs/must-know-security-http-headers-be78aeb93200?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/be78aeb93200</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[starbugs]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Sun, 08 Aug 2021 06:09:44 GMT</pubDate>
            <atom:updated>2021-08-28T13:17:32.545Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5__YcfEcHvg6gXb4zxIfCw.png" /></figure><p>隨著網路上的 Web 應用程式越來越多，為了提升安全性，現在跟安全性有關的 HTTP header 也是多到記不得，像我上 Medium 看我自己的文章，就可以看到 CSP、HSTS、Expect-CT 等等 header</p><p>因為各種不同功能的 HTTP header 實在太多，所以這邊想要介紹幾個比較簡單、好設定的安全性 headers ，只要把這些 headers 加進去，網站就會突然變安全哦～</p><h3>Content Security Policy (CSP)</h3><p>首先是歷史悠久的 CSP，這個 header 是用來限制瀏覽器只能從哪些地方載入資源。譬如說我設定 Content-Security-Policy: default-src larry.com，就代表<strong>我限制瀏覽器只能從 </strong><strong>larry.com 這個網域載入圖片、CSS、字體等等各種資源</strong></p><p>當然想設定很多個網域也是可以的，只要一直往下接就可以了。下圖開發者工具的內容是我上 Github 首頁時 response header 裡的 CSP 設定，他就是把 uploads.github.com、api.github.com 等等很多個網域都加進去，雖然看起來很冗長，但<strong>至少有一個白名單，不會莫名其妙載入其他網域的東西</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JiD_ky-aWR5EWJky_fE7iQ.png" /></figure><p>如果想針對不同類型的資源有不同的 policy（雖然比較麻煩但會更安全），那也可以寫成 Content-Security-Policy: img-src a.com; font-src b.com 的形式，那瀏覽器就會知道你希望只能從 a.com 載入圖片、從 b.com 載入字體</p><blockquote>想看還有哪些屬性可以設定可以參考 <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy#directives">MDN 上的 Directives</a></blockquote><p>那限制網域有什麼用呢？假如哪天駭客在我的網站上發現了一個 XSS 漏洞，讓他可以在首頁的 HTML 中加入一段 &lt;script src=“<a href="http://hacker.com/evil.js">hacker.com/evil.js</a>”&gt;，那每一個使用者到我的網站時瀏覽器就會載入惡意的 evil.js，讓駭客可以做一些壞壞的事情，譬如說重新導向、偷走帳號密碼等等</p><p>但如果有把 CSP 設定成 Content-Security-Policy: default-src larry.com 的話，瀏覽器就會拒絕載入 evil.js（下圖），因為那個腳本是從 <a href="http://hacker.com/">hacker.com</a> 來的。因此<strong>雖然 CSP 不能完全防堵 XSS，但能減輕 XSS 造成的影響，因為如果攻擊者不能從外部載入惡意資源，那可以做的事情也相對比較少一點</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KvEakSVX2NOnNdJ-J30DhQ.png" /></figure><h3>Strict Transport Security (HSTS)</h3><p>HSTS 的全名是 HTTP Strict Transport Security，聽過這個 header 的人可能比較少一點，他是用來<strong>強制瀏覽器只能使用安全的 HTTPS 協定跟網站進行連線</strong>，而不能使用 HTTP</p><p>譬如說很多網站其實用 HTTP 跟 HTTPS 都連得上，但考量到安全性，當然是希望使用者都走 HTTPS。這時只要在 header 裡加上 Strict-Transport-Security: max-age=31536000; includeSubDomains，那在往後的 31536000 秒內（其實就是一年啦XD），只要使用者的瀏覽器看到<strong>這個網域或他的子網域</strong>，就會全部改成用 HTTPS 進行連線，真的是很方便呢</p><p>也因為現在網站幾乎都有 HTTPS 了，所以像平常會用到的 Google、Medium、Facebook 都可以看到 HSTS 的蹤跡，只是大家設定的 max-age 稍有不同，比較常看到的大概會是 31536000（一年）、15552000（180 天）這類的數字</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jC-qwTfKPzLYScJIjrbegQ.png" /></figure><p>雖然在 HTTP header 裡面加上 HSTS 很簡單，但如果你還是覺得麻煩，而且你又剛好有在用 Cloudflare 代管 DNS，那也可以參考<a href="https://blog.cloudflare.com/enforce-web-policy-with-hypertext-strict-transport-security-hsts/">這篇文章</a>直接在 Cloudflare 設定裡面的 Cryptography 啟用 HSTS，那就什麼都不用做哦～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*58eSGWiQuOtYIwz6qFhknw.png" /></figure><h3>X-Content-Type-Options</h3><p>聽過這個 header 的人可能又更少了，在講這個 header 之前，得先來談談什麼是 content sniffing：一般來說瀏覽器會透過 Content-Type 來判斷請求到的資源是什麼類型，像透過 &lt;script src=&quot;script.js&quot;&gt; 拿到的 Content-Type 一般都是 text/javascript，因此瀏覽器看到之後就會拿來執行</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Av8WwAnfHNPXDsAIf6rWVA.png" /></figure><p>但有些網站（尤其是十幾二十年前的舊網站）在開發時並沒有把 Content-Type 設好，導致某些 JS 檔的 Content-Type 是 text/plain，也就是純文字檔。為了讓這些網站可以順利運作，<strong>瀏覽器除了參考 Content-Type 之外，也會做 content sniffing 從檔案內容分析是什麼類型</strong>，如果分析出是 JS 那就會拿去執行，這樣舊網站才不會壞掉</p><p>但 sniffing 這個動作看似貼心，卻也是一個弱點。譬如說有些網站允許使用者上傳檔案，<strong>那攻擊者就可以惡意上傳一些有 JS 特徵的 JPG 檔（這些圖片會被瀏覽器判斷成腳本）</strong>。接著想辦法讓這張圖片被載入到前端來，導致裡面的惡意腳本被執行，造成 XSS 攻擊</p><p>為了防止瀏覽器在那邊亂猜檔案的 Content-Type 是什麼（而且麻煩的是每個瀏覽器猜的方式還不太一樣），我們要在 headers 裡面加上 X-Content-Type-Options: nosniff 告訴瀏覽器直接用 header 裡面提供的 Content-Type 就好，不要在那邊瞎猜，<strong>如此一來就不會再有純文字、圖片被判斷成腳本這種事</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AP1cfD3YAmqG799gC4SQVw.png" /></figure><p>但也因為加了 nosniff，所以務必要注意各種資源的 Content-Type 有沒有設定好，因為瀏覽器不會幫你猜，如果你真的把 JS、CSS 的 Content-Type 設錯，那瀏覽器就不會把它跑起來，網站看起來也就怪怪的</p><h3>X-Frame-Options</h3><p>平常在寫網頁時，若是想把其他網頁的內容拿過來用（下圖），可以用 &lt;iframe src=&quot;https://website.com&quot;&gt; 把他嵌入進來；反之，若是別人想把我做的網站嵌入到他的網站裡面也是可以的</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iB4Owk6j6PoHZK-Lrepsbw.png" /></figure><p>那這樣會有什麼資安疑慮呢？萬一有個壞壞網站，他透過 iframe 把氣象局網頁嵌入進去後，<strong>用 CSS 把那個 iframe 調成透明的，然後在透明的 iframe 背後放一些按鈕</strong>（下圖）。那使用者在壞壞網站上點擊我很帥、我帥爆時，就會不小心點到氣象局的網站，這種攻擊就稱作 Clickjacking</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ZVh1-CPyYivSHJPde3f2A.png" /></figure><p>如果點到的只是氣象局網站那不會怎麼樣，反正怎麼點也就是那樣。但萬一被嵌入的是某銀行的網站呢？那使用者可能就會被精心設計的按鈕給騙到，在無意識的情況下就按了 iframe 裡面的轉帳、提款等等按鈕</p><p>為了要避免這類問題，最好的方法就是加上 X-Frame-Options: deny 這個 header，意思是告訴瀏覽器說我這個網站不想被嵌入（為了安全起來大部分的銀行都會加這個 header）</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*34hbmVsilrsuFAAIzXiMTQ.png" /></figure><p>所以當我想在自己的網站上把玉山銀行的頁面嵌入進來時，瀏覽器就會噴出「ebank.esunbank.com.tw 不允許在被別的網站嵌入」的錯誤。<strong>因為玉山銀行的頁面根本不允許被嵌入，也就避免了基於 iframe 的 Clickjacking 攻擊</strong></p><h3>總結</h3><p>今天介紹了 CSP、HSTS、X-Content-Type-Options 跟 X-Frame-Options 總共四個跟安全性有關的 HTTP headers，這些 headers 不只用起來輕鬆簡單，加上去根本不用十分鐘，而且又可以大幅提高安全性，所以已經是網站開發不可缺少的 HTTP headers 了</p><p>除了這四個之外其實還有 X-XSS-Protection、Expect-CT、Public-Key-Pins、Feature-Policy 等等很多 header，但因為有些效果沒那麼大、有些則是已經被宣佈棄用了，所以這邊就暫且不提，有興趣可以自己到 <a href="https://owasp.org/www-project-secure-headers/">Owasp Secure Headers</a> 上面看看～</p><h4>延伸閱讀</h4><ul><li><a href="https://blog.huli.tw/2021/02/19/cors-guide-1/">CORS 完全手冊（一）：為什麼會發生 CORS 錯誤？</a></li><li><a href="https://blog.huli.tw/2021/06/19/xss-attack-and-defense/">淺談 XSS 攻擊與防禦的各個環節</a></li><li><a href="https://devco.re/blog/2014/06/03/http-session-protection/">HTTP Session 攻擊與防護</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be78aeb93200" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/must-know-security-http-headers-be78aeb93200">你不能不知道的安全性 HTTP headers</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[淺談 Shamir 私鑰分割演算法：切一切再拼回來]]></title>
            <link>https://medium.com/starbugs/introduction-to-shamirs-secret-sharing-adf713e6430d?source=rss-c3d4e0232dc0------2</link>
            <guid isPermaLink="false">https://medium.com/p/adf713e6430d</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[starbugs]]></category>
            <category><![CDATA[crypto]]></category>
            <dc:creator><![CDATA[Larry Lu]]></dc:creator>
            <pubDate>Sun, 11 Jul 2021 02:57:07 GMT</pubDate>
            <atom:updated>2021-07-12T13:47:35.109Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YUwY6FLHIXGKJ5oi-OW44Q.png" /></figure><p>現代密碼學從 20 世紀中葉發展至今，已經有很多非常經典的加密演算法如 AES、RSA 等等，這些演算法經過各方驗證，<strong>沒有密碼或 private key 是絕對不可能把明文解出來的</strong>。所以重點就變成該如何保存好密碼，讓密碼<strong>不會輕易被偷走、而且也絕對不會弄丟</strong>（弄丟這世界上就沒人解得開了XD）</p><p>但要保存好密碼可不容易，因為<strong>不管是把密碼放在什麼服務上，那個服務都有可能被攻破、被 DDOS 打掛、中勒索病毒等等</strong>，導致你的密碼外洩或是在需要時拿不回來</p><p>雖說上了網就一定有風險，但自己保存也不見得是好主意。譬如說把密碼存在隨身碟、抄在紙條藏在衣櫃等等（聽說有比特幣大戶就是這樣保存錢包私鑰XD），哪天不小心硬碟壞掉（我就壞過兩次）、發生火災、家裡淹水，鉅額財產可能就直接拜拜了～</p><h3>Shamir’s Secret Sharing</h3><p>而 Shamir’s Secret Sharing（簡稱 SSS）私鑰分割演算法正是要解決上述的問題，他可以幫你<strong>把 secret 用數學原理分割成 n 個不同的 share，並且你只需要其中 k 個 share 就可以拼回原本的 secret</strong>（n 跟 k 可以自己設定）</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TNyhYOWmLT0tzRiP87icOg.png" /></figure><p>那這有什麼用呢？假如我們 Starbugs 手上有一份超超機密文件，洩漏出去會出事的那種。那就可以把文件用 AES 加密起來後，將密碼（secret key）用 n=4、k=3 分割成<strong>四份不同的 share</strong> 由我、神Q、Luka、小城各持有一份，並且每人把 share 放在不同的服務上</p><p>因為 k=3 的關係，<strong>駭客如果想還原出密碼就必須取得其中三份 share</strong>，也就是說他必須攻破其中三個服務才行。而且也因為 k=3，所以即便哪天我把自己那份 share 弄丟了，<strong>還是可以靠其他三人的 share 還原出文件</strong>，聽起來很不錯吧～</p><blockquote>那這麼強大的演算法，鐵定需要很高深的數學對吧？</blockquote><p>沒有哦，其實這個演算法只會用到國中數學，所以今天就是要跟大家介紹 Shamir’s Secret Sharing 演算法的原理，也讓大家對於數學如何應用在密碼學上有點概念～</p><h3>分割 secret</h3><h4>Step 1 — 準備隨機函數</h4><p>Shamir’s Secret Sharing 演算法的內容是這樣的，假設我想要分割的 secret 是 101，而且我希望分割成四份 share（n=4）、有其中三份 share 即可還原出 secret（k=3），那我就先隨機生成一個 <strong>k-1</strong> 次方的函數，並且<strong>把常數項設為 secret</strong></p><p>以這例子來說 k=3，那就隨機生一個二次函數 f(x) = 2x²-9x+101（他的<strong>常數項 101 就是我們想要分割的 secret</strong>），畫成圖是一個漂亮的二次曲線，而且通過 (0, 101) 這個點</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8b4xYH3qb5Zh09uZhzFDvQ.png" /></figure><h4>Step 2 — 在函數上找 n 個點作為 share</h4><p>有了函數之後，接下來就隨機在函數上找 n 個點，這邊為了方便計算我找的是 (-8,301)、(-4,169)、(6,119)、(12,281) 四點（n=4），真的寫成程式的話就隨機找幾個數字，然後帶入函數 f(x) 隨機找出一些點就可以了</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*66hEQmWZmfo3eTe0VhNXUg.png" /></figure><p>有這四點後，接著就是<strong>把原本的 secret 101 銷毀掉</strong>，並<strong>給每人一個點作為各自的 share</strong>，譬如說我拿 (-8,301)、小城拿 (-4,169)、神 Q 拿 (6,119) 等等，就這樣一人一個 share，每個人要負責把自己的 share 保存好</p><p>分割 secret 的步驟到這邊就完成了，簡單來說就是把 secret 藏在函數的常數項，然後只給每人一個點。如此一來就<strong>沒有人知道真正的 secret 是 101</strong>，每個人又只有手中的一個點，所以也<strong>不可能知道函數 f(x) 的全貌</strong></p><h3>還原 secret</h3><h4>Step 1 — 假設 k-1 次函數</h4><p>還原 secret 的方式也很簡單，就是<strong>透過多個點把原本的函數還原出來</strong>，知道函數後取其常數項就是 secret 了</p><p>因為我們知道知道 k=3，<strong>代表一開始的 f(x) 是一個二次函數</strong>，所以我們就假設原本的二次函數長這樣，其中 a、b、secret 都是未知數</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*PvtRzT31Bc-c767ZAd4uoA.png" /></figure><h4>Step 2 — 解開連立方程式</h4><p>假如今天我的那份 share 不見了（我真的很常弄丟東西XD），只剩下另外三份 share 分別是 (-4,169)、(6,119)、(12,281)</p><p>因為<strong>我們知道 f(x) 通過這三個點</strong>，因此就可以把三個點帶入 f(x) 中得到連立方程組，把原本函數長什麼樣子算出來</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uyj273fL5Us51B6CrmiYmw.png" /></figure><p>從這個例子也可以看出，雖然我弄丟了一個 share，但因為 k=3，所以<strong>即便只有三個 share 還是可以反推出原函數</strong> f(x) = 2x²-9x+101，也就知道 secret 是 101</p><p>到這邊我想大家都看懂 Shamir’s Secret Sharing 演算法了，簡單來說 <strong>SSS 就是把 secret 藏在函數的常數項</strong>。所以<strong>要還原 secret 也是先用多個點反推出原本的函數，再取其常數項就是 secret</strong></p><p>如果還是覺得哪邊不太懂可以多看幾次上面那段，用到的數學都不難所以應該很快就能看懂</p><h3>常見問題</h3><h4>如果 share 太少有可能猜出 secret 嗎</h4><p>以同一個例子來說，如果你只有其中兩個 share，也就是還少一個 share，那你列出來的連立方程式就只會有兩個</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-2rKBazvQHwhel1xAkmoOQ.png" /></figure><p>大家這麼聰明，應該都知道<strong>兩個方程式不可能解出三個未知數</strong>，所以最後只能得到 secret = 149 — 24a 這樣的關係式。又因為 a 可以是任意數，換句話說可能的 (a, secret) 組合仍然有無限多個，所以還是找不出真正的 secret（除非你的 a 數字太小，一下子就被猜到了）</p><h4>secret 只能是數字嗎？</h4><p>這應該是很多人關心的問題，畢竟大部分的 secret 都不會只有數字。雖然上面是以單純數字為例，<strong>但 secret 可以有各種形式，只要他們最後被編碼成數字就可以了</strong></p><p>譬如說我設下的 secret 是 你好，根本不可能拿來做數學運算。但我可以先把 你好 在記憶體中的樣子用 16 進位輸出得到 e4bda0e5a5bd 字串，接著再把這字串轉換成十進位得到 251503099356605，然後就可以用上述的演算法把這個巨大數字放在常數項去做分割</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GMmPZOwHJ1pJXpBvQinutA.png" /></figure><p>還原也是一樣，解開連立方程式得到 secret 是 251503099356605 後，就先把它轉成 16 進位，接著再重新編碼成 UTF8 格式就能得到 你好 了～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f8D8PKYTZxg0r-BHRZgQPg.png" /></figure><p>因此只要你有某個編碼方法可以把字串轉成數字、數字轉回字串，那就可以運用 SSS 演算法來保護任何形式的 secret，並沒有限定 secret 一定要是數字</p><h4>secret 可以多長</h4><p>既然 secret 可以被編碼成數字，那說真的 secret 多長都可以，就算編碼出來的數字有一萬位數，遠遠超過 int64 的極限，那也只需要把大數運算開下去就什麼都算得出來～</p><p>雖然大數運算是用二進位模擬十進位做計算，速度鐵定會比較慢，但因為產生隨機數、在函數上找點、解聯立方程式這幾個動作都非常簡單，也不需要太複雜的計算，所以就算慢個十倍以現在的 CPU 跑起來還是非常快</p><p>順帶一提現在很多語言都有內建大數運算了，像 Go 的 <a href="https://golang.org/pkg/math/big/">math/big</a> 跟 JS 的 <a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/BigInt">BigInt</a> 用起來都很簡單哦～</p><h3>實際玩玩看</h3><p>關於 Shamir’s Secret Sharing 的原理就講到這，有很多用來管理 secret 的工具如 HashiCorp Vault 都會用 SSS 來分割重要的 key，而且 Github 上有滿多 SSS 演算法的實作，我看了一下 <a href="http://point-at-infinity.org/ssss/">ssss</a> 這個 CLI 大概是用起來最簡單的，而且他支援直接輸入 ASCII 字串，這邊來實際操作一下</p><p>首先我想要把 starbugs weekly is awesome 這串 secret 分割成五份 share、只要有其中三份就能解回來。那我就下指令 ssss-split -n 5 -t 3 接著再輸入 secret，從下圖中可以看出來他已經把我的 secret（隱藏起來了）分割成五份 share（<strong>每個 share 實際上都是一個點</strong>），而且每個 share 都長到記不起來</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yuBlzMRq1wNbF2mjABlUFQ.png" /></figure><p>如果有一天需要還原時也很簡單，只要下指令 ssss-combine -t 3 然後隨便丟三份 share 進去就拼回來了，而<strong>內部原理就是他會用三個點拼出原函數，再取其常數項的 secret</strong>，很有趣吧～</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iJ00gpDgR4wzaTKVfdd1Nw.png" /></figure><h3>結論</h3><p>大部分的密碼學工具背後的數學原理其實都有點難度，而且常常需要用到線性代數跟數論相關的定理，Shamir’s Secret Sharing 算是少數只需要簡單數學而且又非常實用的</p><p><strong>他就只是把 secret 藏在一個隨機函數中的常數項，然後每個 share 都是方程式上的一個點。如此一來就沒有人可以知道函數原本的樣子，除非湊齊足夠多的點才能把原函數還原出來，再得到方程式的常數項（也就是 secret）</strong></p><p>雖然把 secret 分割之後還是有機率外洩（可能某駭客組織為了偷取 Starbugs 的機密而盜我帳號、威脅神 Q、賄賂 Luka），但<strong>至少可以大幅提高攻擊者的成本</strong>，畢竟在資安領域本來就沒有絕對的安全，你只能不斷提高攻擊者的成本，<strong>當這個成本已經遠大過攻擊能帶來的利益時，那就可以說是足夠安全了</strong></p><h4>延伸閱讀</h4><ul><li><a href="https://medium.com/starbugs/what-are-encoding-encrypt-and-hashing-4b03d40e7b0c">一次搞懂密碼學中的三兄弟 — Encode、Encrypt 跟 Hash</a></li><li><a href="https://medium.com/starbugs/how-to-store-password-in-database-sefely-6b20f48def92">聽說不能用明文存密碼，那到底該怎麼存？</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=adf713e6430d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/starbugs/introduction-to-shamirs-secret-sharing-adf713e6430d">淺談 Shamir 私鑰分割演算法：切一切再拼回來</a> was originally published in <a href="https://medium.com/starbugs">Starbugs Weekly 星巴哥技術專欄</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>