One 、 Verification rules of bank card number

The verification of bank card number adopts Luhn Algorithm , The verification process is roughly as follows ：

1. Number the card number string from right to left , The first on the far right is 1, The second on the far right is 2, The third on the far right is 3….

2. Traverse from right to left , For each character t Perform the third step , And add the calculation results of each bit to get a number s.

3. Calculation rules for each bit ： If this one is odd , Then return to t In itself , If it's an even number , The first will t multiply 2 Get a number n, If n It's one digit. （ Less than 10）, Go straight back to n, Otherwise it would be n Add the single digit and ten digit of to return .

4. If s Be able to divide 10, Then this number is valid , Otherwise... The number is invalid .

Because the final result will be right 10 Take the remainder to determine whether it can be divided 10, So it is also called module 10 Algorithm .

Two 、 Generating coincidence Luhn Regular bank card number test data

Now that I have found out the verification rules of bank card number , Then you can generate some rules that can pass Luhn Verified test data .

Ideas ：

Because the rightmost digit is odd , Odd digits don't need to change the value, just put what you want , This feature is important , It can be used to make up just enough to divide 10.

So obviously it can be inferred that he was born into n Bit coincidence Luhn Regular algorithm ：

1. Random generation n-1 Bit character , Called string x.

2. Let's assume that the string x Yes n position （ In fact, the missing one on the far right is n-1 position , The last one uses 0 Fill in the space ）, take x according to n Bit length calculation and s,

3. In the previous step, we get the string x Checksum s, take s Add a number y, So that it can just divide 10, This y It's the number that should be placed first on the far right .

4. x+y Do string splicing , To get the final n Bit coincidence Luhn The string of the rule .

The whole code is as follows ：

package main

import (
	"fmt"
	"math/rand"
	"strconv"
	"time"
)

func main() {
	fmt.Println(checkCarNum("6226095711989751"))
	cardNum := genCardNum("622609", 16)
	fmt.Println(cardNum)
	fmt.Println(checkCarNum(cardNum))
}

func checkCarNum(cardNum string) bool {
	sum, err := getCardNumSum(cardNum)
	if err != nil {
		return false
	}
	return sum%10 == 0
}

func getCardNumSum(cardNum string) (int64, error) {
	sum := int64(0)
	length := len(cardNum)
	index := length - 1
	for {
		t, err := strconv.ParseInt(string(cardNum[index]), 10, 64)
		if err != nil {
			return 0, err
		}

		if index%2 == 0 {
			t = t * 2
			if t >= 10 {
				t = t%10 + t/10
			}
		}

		sum += t
		if index <= 0 {
			break
		}
		index--
	}
	return sum, nil
}

func genCardNum(startWith string, totalNum int) string {
	result := startWith
	length := len(result)
	rand.New(rand.NewSource(time.Now().UnixNano()))
	for {
		result += fmt.Sprintf("%d", rand.Intn(10))
		if length == totalNum-1 {
			break
		}
		length++
	}

	sum, _ := getCardNumSum(result + "0")
	t := 10 - sum%10
	if t == 10 {
		t = 0
	}

	result += fmt.Sprintf("%d", t)
	return result
}

Reference resources ： Bank card number verification algorithm （Luhn Algorithm , It's also called model 10 Algorithm ） - CC11001100 - Blog Garden