chatGPTが続きを書いてくれなくなった
2023-06-10 10:28:30 continue generatingが実装された
以前は「続けてください」「続きをお願いします」と書けば続きを出してくれたはずなのだが、同じ内容を最初から出力し直されてしまった
(注：改行と送信を間違え、記事をコピペせずにメッセージを送ってしまった)
Once in a while, you'll find the need to generate some secrets for your users on the browser. It might seem tempting to write a one-liner like Math.random().toString(36).slice(2) and call it a day. The generated strings might seem random but are not cryptographically secure. I'm sure you are not surprised.
In most browsers, Math.random() is implemented using a pseudo-random number generator (PRNG). This means that the random number is derived from an internal state, mangled by a deterministic algorithm for every new random number. It seems random to the user because the algorithm is tuned in such a way that it appears so. However, if you know the generator's internal state, you know all the future numbers generated by it.
About Math.random
As the ECMAScript specifications don't define the algorithm for a Math.random implementation, developers building browsers can choose the implementation they see fit. Ideally, the algorithm should use as little memory as possible and be quick to perform while having a significant period length.
The period length of a PRNG is the number of output bits after which the algorithm begins to repeat itself.
Most modern browsers today use the xorshift128+. (Read why Chrome V8 switched to this algorithm). It is one of the fastest non-cryptographically-secure random number generators. You can read more about the implementation of Math.random() in this article.
These algorithms, including the xorshift can be broken — here is an article about it. The internet has seen many instances where older implementations have been susceptible to simple prediction attacks, the most popular one I know from my college gaming days is from CSGOJackpot. Here's more to read on that. More such stories such as this and this tell us why using Math.random() is not a great idea. While these hacks may not be exploitable today, it does surface the weakness of PRNGs to be used in this context. A deterministic algorithm can and will be broken.
The Web Cryptography API has got you covered
In 2017, World Wide Web Consortium (W3C) presented the Web Cryptography API. It provides a set of cryptographic primitives that can perform basic operations such as hashing, signature generation and verification, and encryption and decryption. Additionally, it describes an API for applications to generate and manage the keying material necessary to perform these operations. Read more on MDN.
All popular browsers provide an implementation of the Web Crypto API to JavaScript applications through the semi-global crypto object. For generating secrets, the getRandomValues method is all we need. The method is widely supported and generates cryptographically secure random numbers. It takes in a typedArray as an input and returns the same array, with its contents replaced with the newly generated random numbers.
crypto.getRandomValues(new Uint8Array(10))
// Uint8Array(10) 137, 32, 62, 244, 157, 240, 103, 42, 47, 57
Implementations don't use a truly random number generator to guarantee enough performance. Instead, they use a pseudo-random number generator seeded with a value with enough entropy. This ensures there's a good balance between performance and the quality of the randomness generated. Since the seed value is random, the output is cryptographically secure.
While the methods and primitives provided by this API are inherently secure, it's easy to use them wrong. While using it, ensure your work is reviewed thoroughly by someone knowledgeable in this subject.
Using the API to generate secrets
Step 1: Generating the seed
The seed is a Uint8 Array that is filled with random numbers using getRandomValues. Uint8Array generates an array of 8-bit unsigned integers.
generateSeed() {
return window.crypto.getRandomValues(new Uint8Array(256));
}
Step 2: Looping over the seed
We loop over the generated seed until the character length is satisfied. If we've exhausted the seed before that, the seed is generated again. We use String.fromCharCode to generate a character inside the loop. If it is valid, it is appended to the secret string returned at the end of the function.
generate(length = 32): string {
let secret = "";
let randomSeed;
while (secret.length < length) {
randomSeed = generateSeed()
for (let ii = 0; ii < randomSeed.length; ii++) {
const char = String.fromCharCode(randomSeedii);
// Append the character to secret if it is valid
if (validateCharacter(char)) {
secret += char;
}
if (secret.length === length) {
break;
}
}
}
return secret;
}
The generated character will always belong to the ASCII set. The validate function simply checks if it belongs to the ASCII printable characters, i.e., letters, digits, punctuation marks, and a few miscellaneous symbols.
Introducing Shifty
Sometimes the browser may not support the web crypto API. In such cases, developers have no other choice but to fall back on Math.random. Recently, we published a library that takes care of this in a tiny package. It's called Shifty.
expand on that
Shifty is a tiny zero-dependency secrets generator built for the web using TypeScript. Shifty is made for the browser and won't work with Node. You can use the built-in crypto module instead.
It provides a straightforward API to generate a secret of any length. To start using shifty, just install it using the package manager of your choice.
yarn add @deepsource/shifty
Using Shifty is quite straightforward. Just initialize the Shifty class with the defaults and use the generate method to generate secrets of any length. Shifty falls back to using Math.random if the crypto object is not present on window. It shows a warning on the developer console when using the fallback method.
import Shifty from '@deepsource/shifty'
const shifty = new Shifty((harden = true), (defaultLength = 16))
shifty.generate((length = 12)) // G8qZt7PEha^s
Shifty is just a single TypeScript file. You can peek into the source code here. Give it a star if you like it!
(注：元記事のソース紛失)
Shifty is a JavaScript library for generating cryptographically secure random numbers on the web. It is built using TypeScript and is a zero-dependency library, meaning that it does not require any external dependencies to work. Shifty is specifically designed to work in the browser and is not compatible with Node.
The library provides a simple API for generating secure secrets in the form of strings. Shifty first checks if the Web Cryptography API is available in the browser, and if it is, it uses the getRandomValues method to generate secure random numbers. If the Web Crypto API is not available, Shifty falls back to Math.random, which is not cryptographically secure but is still better than not having any random number generator at all.
To use Shifty, you can simply import it into your JavaScript file and call the generate method. You can pass the desired length of the secret as a parameter to the generate method, and it will return the secret string. The generated secret string consists of printable ASCII characters, and the library includes a validation function to check if the characters belong to the ASCII printable set.
Overall, Shifty is a small but useful library for generating secure secrets in the browser. If you're working on a web project that requires the generation of secrets, Shifty is a great choice that takes care of the compatibility issues and provides a simple API to use.
一般的に、組み込みのJavaScriptのMath.random()関数には、次のような問題があります。
1. 不確定性: Math.random()関数は、疑似乱数ジェネレータを使用しているため、完全にランダムな数値を生成することは保証されません。一部の乱数ジェネレータは、短期間で同じ数字を繰り返し生成する場合があります。
2. 順序: Math.random()関数は、次に生成される数字を予測することができないため、順序に依存するアルゴリズムには使用できません。
3. シード値: Math.random()関数は、同じシード値を使用すると、同じ数字を生成するため、テスト用途などで予測可能な数字を生成する必要がある場合は適しません。
これらの問題を回避するためには、別の乱数ジェネレータライブラリを使用するか、Math.random()関数をカスタマイズすることができます。
次に示す記事もふまえて、今のV8でのMath.random()の実装を日本語で説明してください。
(この記事の全文を貼り付けた)
Math.random()は、Javascriptで最もよく知られて使われている乱数の生成方法です。V8やほとんどのJavascriptエンジンでは、疑似乱数生成器（PRNG）を使って実装されています。PRNGによって生成される乱数は、内部の状態から生成され、新しい乱数を生成するたびに固定アルゴリズムによって変更されます。そのため、与えられた初期状態に対して、乱数のシーケンスは決定的です。内部の状態のビット数が限られているため、PRNGが生成する数字は最終的に繰り返されます。この変換周期の長さの上限は2^nです。
PRNGのアルゴリズムには多数の種類がありますが、最もよく知られているものにはメルセンヌツイスターとLCGがあります。それぞれに特徴、利点、欠点があります。理想的には、初期状態に必要なメモリが少ないこと、高速に実行されること、大きい周期長を持つこと、高品質のランダムな分布を提供することが望まれます。メモリ使用量、パフォーマンス、周期長は簡単に測定または計算することができますが、品質は評価するのが困難です。ランダムな数字の品質を確認するための統計的テストには多くの数学が隠されています。デファクトスタンダードのPRNGテストスイート、TestU01は、これらのテストの多くを実装しています。
最近まで（version 4.9.40まで）、V8の選択したPRNGはMWC1616（multiply with carry、2つの16ビット部分を組み合わせ）でした。64
V8とほとんどの他のJavaScriptエンジンでは、Math.random()は擬似乱数生成器（PRNG）を使って実装されています。すべてのPRNGにおいて、ランダムな数値は内部の状態から派生しますが、新しいランダムな数値に対して固定のアルゴリズムで変更されます。したがって、特定の初期状態に対して、ランダムな数列は決定論的です。内部の状態のビットサイズnが制限されているため、PRNGが生成する数値は最終的に繰り返します。この並べ替えサイクルの期間の長さの上限は2nです。
様々なPRNGアルゴリズムがあります。最もよく知られているものにはMersenne-TwisterとLCGがあります。それぞれには特定の特性、利点、欠点があります。理想的には、初期状態に必要なメモリが少ない、実行が速い、期間長が大きく、高品質のランダム分布を提供するものが使われるべきです。メモリ使用、パフォーマンス、期間長は簡単に測定または計算できますが、品質は測定しづらいものです。ランダムな数値の品質を検証する統計的テストには多くの数学があります。デファクトスタンダードのPRNGテストスイート、TestU01はその多くのテストを実装しています。
最近（バージョン4.9.40まで）、V8の選択したPRNGはMWC1616（multiply with carry、2つの16ビット部分を結合）でした。これは64ビットの内部状態を使用し、次のような形になっています。
V8 7.1では実装が再調整され、state
明らかに続きではなく、同じことを初めから説明し直している
(また最初から説明し始めたので中断した)
質問の仕方が悪かったのかな？
#2023-06-10 10:28:58
#2023-03-20 12:04:25
#2023-02-13 00:53:43