User-provided data matching

  /** 
 * @fileoverview Provides the hashing algorithm for User-Provided Data Match, as 
 * well as some valid hashes of sample data for testing. 
 */ 
 async 
  
 function 
  
 hash 
 ( 
 token 
 ) 
  
 { 
  
 // Removes leading or trailing spaces and converts all characters to lowercase. 
  
 const 
  
 formattedToken 
  
 = 
  
 token 
 . 
 trim 
 (). 
 toLowerCase 
 (); 
  
 // Hashes the formatted string using the SHA-256 hashing algorithm. 
  
 const 
  
 hashArrayBuffer 
  
 = 
  
 await 
  
 crypto 
 . 
 subtle 
 . 
 digest 
 ( 
  
 'SHA-256' 
 , 
  
 ( 
 new 
  
 TextEncoder 
 ()). 
 encode 
 ( 
 formattedToken 
 )); 
  
 // Converts the hash buffer to a hexadecimal string. 
  
 return 
  
 Array 
 . 
 from 
 ( 
 new 
  
 Uint8Array 
 ( 
 hashArrayBuffer 
 )) 
  
 . 
 map 
 (( 
 b 
 ) 
  
 = 
>  
 b 
 . 
 toString 
 ( 
 16 
 ). 
 padStart 
 ( 
 2 
 , 
  
 '0' 
 )) 
  
 . 
 join 
 ( 
 '' 
 ); 
 } 
 function 
  
 main 
 () 
  
 { 
  
 // Expected hash for test@gmail.com: 
  
 // 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674 
  
 hash 
 ( 
 'test@gmail.com' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
  
 // Expected hash for +18005551212: 
  
 // 61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44 
  
 hash 
 ( 
 '+18005551212' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
  
 // Expected hash for John: 
  
 // 96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a 
  
 hash 
 ( 
 'John' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
  
 // Expected hash for Doe: 
  
 // 799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f 
  
 hash 
 ( 
 'Doe' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
 } 
 main 
 () 
 

  /** 
 * @fileoverview Provides the hashing algorithm, as well as some valid hashes of 
 * sample data for testing. 
 */ 
 async 
  
 function 
  
 hash 
 ( 
 token 
 ) 
  
 { 
  
 // Removes leading or trailing spaces and converts all characters to lowercase. 
  
 const 
  
 formattedToken 
  
 = 
  
 token 
 . 
 trim 
 (). 
 toLowerCase 
 (); 
  
 // Hashes the formatted string using the SHA-256 hashing algorithm. 
  
 const 
  
 hashBuffer 
  
 = 
  
 await 
  
 crypto 
 . 
 subtle 
 . 
 digest 
 ( 
  
 'SHA-256' 
 , 
  
 ( 
 new 
  
 TextEncoder 
 ()). 
 encode 
 ( 
 formattedToken 
 )); 
  
 // Converts the hash buffer to a base64-encoded string and returns it. 
  
 const 
  
 base64Str 
  
 = 
  
 btoa 
 ( 
 String 
 . 
 fromCharCode 
 (... 
 new 
  
 Uint8Array 
 ( 
 hashBuffer 
 ))); 
  
 return 
  
 base64Str 
 ; 
 } 
 function 
  
 main 
 () 
  
 { 
  
 // Expected hash for test@gmail.com: 
  
 // h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ= 
  
 hash 
 ( 
 'test@gmail.com' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
  
 // Expected hash for +18005551212: 
  
 // YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ= 
  
 hash 
 ( 
 '+18005551212' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
  
 // Expected hash for John: ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo= 
  
 hash 
 ( 
 'John' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
  
 // Expected hash for Doe: eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8= 
  
 hash 
 ( 
 'Doe' 
 ). 
 then 
 ( 
 result 
  
 = 
>  
 console 
 . 
 log 
 ( 
 result 
 )); 
 } 
 main 
 () 
 

  """Provides the hashing algorithm, as well as some valid hashes of sample data for testing. 
 Supports: Python 2, Python 3 
 Sample hashes: 
 - Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674 
 - Phone '+18005551212':   61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44 
 - First name 'John':      96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a 
 - Last name 'Doe':        799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f 
 """ 
 import 
  
 base64 
 import 
  
 hashlib 
 def 
  
 updm_hash 
 ( 
 token 
 ): 
 # Generates a SHA-256 hash of the input token after normalization. 
 return 
 hashlib 
 . 
 sha256 
 ( 
 token 
 . 
 strip 
 () 
 . 
 lower 
 () 
 . 
 encode 
 ( 
 'utf-8' 
 )) 
 . 
 hexdigest 
 () 
 def 
  
 print_updm_hash 
 ( 
 token 
 ): 
 # Prints the SHA-256 hash and the original token. 
 print 
 ( 
 'Hash: " 
 {} 
 " 
 \t 
 (Token: 
 {} 
 )' 
 . 
 format 
 ( 
 updm_hash 
 ( 
 token 
 ), 
 token 
 )) 
 def 
  
 main 
 (): 
 # Hashes and prints sample tokens. 
 print_updm_hash 
 ( 
 'test@gmail.com' 
 ) 
 print_updm_hash 
 ( 
 '+18005551212' 
 ) 
 print_updm_hash 
 ( 
 'John' 
 ) 
 print_updm_hash 
 ( 
 'Doe' 
 ) 
 if 
 __name__ 
 == 
 '__main__' 
 : 
 main 
 () 
 

  """Provides the hashing algorithm, as well as some valid hashes of sample data for testing. 
 Supports: Python 2, Python 3 
 Sample hashes: 
 - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ= 
 - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ= 
 - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo= 
 - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8= 
 """ 
 import 
  
 base64 
 import 
  
 hashlib 
 def 
  
 hash 
 ( 
 token 
 ): 
 # Generates a base64-encoded SHA-256 hash of a normalized input string. 
 return 
 base64 
 . 
 b64encode 
 ( 
 hashlib 
 . 
 sha256 
 ( 
 token 
 . 
 strip 
 () 
 . 
 lower 
 () 
 . 
 encode 
 ( 
 'utf-8' 
 )) 
 . 
 digest 
 ()) 
 . 
 decode 
 ( 
 'utf-8' 
 ) 
 def 
  
 print_hash 
 ( 
 token 
 , 
 expected 
 = 
 None 
 ): 
 # Computes and displays the hash of a token, with optional validation. 
 hashed 
 = 
 hash 
 ( 
 token 
 ) 
 if 
 expected 
 is 
 not 
 None 
 and 
 hashed 
 != 
 expected 
 : 
 print 
 ( 
 'ERROR: Incorrect hash for token " 
 {} 
 ". Expected " 
 {} 
 ", got " 
 {} 
 "' 
 . 
 format 
 ( 
 token 
 , 
 expected 
 , 
 hashed 
 )) 
 return 
 print 
 ( 
 'Hash: " 
 {} 
 " 
 \t 
 (Token: 
 {} 
 )' 
 . 
 format 
 ( 
 hashed 
 , 
 token 
 )) 
 def 
  
 main 
 (): 
 # Tests the hash function with sample tokens and expected results. 
 print_hash 
 ( 
 'test@gmail.com' 
 , 
 expected 
 = 
 'h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=' 
 ) 
 print_hash 
 ( 
 '+18005551212' 
 , 
 expected 
 = 
 'YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=' 
 ) 
 print_hash 
 ( 
 'John' 
 , 
 expected 
 = 
 'ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=' 
 ) 
 print_hash 
 ( 
 'Doe' 
 , 
 expected 
 = 
 'eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=' 
 ) 
 if 
 __name__ 
 == 
 '__main__' 
 : 
 main 
 () 
 

  /* 
 Provides the hashing algorithm, as well as some valid hashes of sample data for testing. 
 Sample hashes: 
 - Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674 
 - Phone '+18005551212':   61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44 
 - First name 'John':      96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a 
 - Last name 'Doe':        799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f 
 */ 
 package 
  
 main 
 import 
  
 ( 
  
 "crypto/sha256" 
  
 "fmt" 
  
 "strings" 
 ) 
 // Hash hashes an email, phone, first name, or last name into the correct format. 
 func 
  
 Hash 
 ( 
 token 
  
 string 
 ) 
  
 string 
  
 { 
  
 formatted 
  
 := 
  
 strings 
 . 
 TrimSpace 
 ( 
 strings 
 . 
 ToLower 
 ( 
 token 
 )) 
  
 hashed 
  
 := 
  
 sha256 
 . 
 Sum256 
 ([] 
 byte 
 ( 
 formatted 
 )) 
  
 encoded 
  
 := 
  
 fmt 
 . 
 Sprintf 
 ( 
 "%x" 
 , 
  
 hashed 
 [:]) 
  
 return 
  
 encoded 
 } 
 // PrintHash prints the hash for a token. 
 func 
  
 PrintHash 
 ( 
 token 
  
 string 
 ) 
  
 { 
  
 fmt 
 . 
 Printf 
 ( 
 "Hash: \"%s\"\t(Token: %s)\n" 
 , 
  
 Hash 
 ( 
 token 
 ), 
  
 token 
 ) 
 } 
 func 
  
 main 
 () 
  
 { 
  
 PrintHash 
 ( 
 "test@gmail.com" 
 ) 
  
 PrintHash 
 ( 
 "+18005551212" 
 ) 
  
 PrintHash 
 ( 
 "John" 
 ) 
  
 PrintHash 
 ( 
 "Doe" 
 ) 
 } 
 

  /* 
 Provides the hashing algorithm, as well as some valid hashes of sample data for testing. 
 Sample hashes: 
 - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ= 
 - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ= 
 - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo= 
 - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8= 
 */ 
 package 
  
 main 
 import 
  
 ( 
  
 "crypto/sha256" 
  
 "encoding/base64" 
  
 "fmt" 
  
 "strings" 
 ) 
 // Hash hashes an email, phone, first name, or last name into the correct format. 
 func 
  
 Hash 
 ( 
 token 
  
 string 
 ) 
  
 string 
  
 { 
  
 formatted 
  
 := 
  
 strings 
 . 
 TrimSpace 
 ( 
 strings 
 . 
 ToLower 
 ( 
 token 
 )) 
  
 hashed 
  
 := 
  
 sha256 
 . 
 Sum256 
 ([] 
 byte 
 ( 
 formatted 
 )) 
  
 encoded 
  
 := 
  
 base64 
 . 
 StdEncoding 
 . 
 EncodeToString 
 ( 
 hashed 
 [:]) 
  
 return 
  
 encoded 
 } 
 // PrintHash prints the hash for a token. 
 func 
  
 PrintHash 
 ( 
 token 
  
 string 
 ) 
  
 { 
  
 fmt 
 . 
 Printf 
 ( 
 "Hash: \"%s\"\t(Token: %s)\n" 
 , 
  
 Hash 
 ( 
 token 
 ), 
  
 token 
 ) 
 } 
 func 
  
 main 
 () 
  
 { 
  
 PrintHash 
 ( 
 "test@gmail.com" 
 ) 
  
 PrintHash 
 ( 
 "+18005551212" 
 ) 
  
 PrintHash 
 ( 
 "John" 
 ) 
  
 PrintHash 
 ( 
 "Doe" 
 ) 
 } 
 

  package 
  
 updm.hashing 
 ; 
 import static 
  
 java.nio.charset.StandardCharsets.UTF_8 
 ; 
 import 
  
 com.google.common.base.Ascii 
 ; 
 import 
  
 com.google.common.hash.Hashing 
 ; 
 /** 
 * Example of the UPDM hashing algorithm using hex-encoded SHA-256. 
 * 
 * <p>This uses the Guava Hashing to generate the hash: https://github.com/google/guava 
 * 
 * <p>Sample valid hashes: 
 * 
 * <ul> 
 *   <li>Email "test@gmail.com": "87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674" 
 *   <li>Phone "+18005551212": "61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44" 
 *   <li>First name "John": "96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a" 
 *   <li>Last name "Doe": "799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f" 
 * </ul> 
 */ 
 public 
  
 final 
  
 class 
 HashExample 
  
 { 
  
 private 
  
 HashExample 
 () 
  
 {} 
  
 public 
  
 static 
  
 String 
  
 hash 
 ( 
 String 
  
 token 
 ) 
  
 { 
  
 // Normalizes and hashes the input token. 
  
 String 
  
 formattedToken 
  
 = 
  
 Ascii 
 . 
 toLowerCase 
 ( 
 token 
 ). 
 strip 
 (); 
  
 return 
  
 Hashing 
 . 
 sha256 
 (). 
 hashString 
 ( 
 formattedToken 
 , 
  
 UTF_8 
 ). 
 toString 
 (); 
  
 } 
  
 public 
  
 static 
  
 void 
  
 printHash 
 ( 
 String 
  
 token 
 ) 
  
 { 
  
 // Calculates and prints the token's hash. 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "Hash: \"%s\"\t(Token: %s)\n" 
 , 
  
 hash 
 ( 
 token 
 ), 
  
 token 
 ); 
  
 } 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 { 
  
 // Executes hash calculations and prints results for sample tokens. 
  
 printHash 
 ( 
 "test@gmail.com" 
 ); 
  
 printHash 
 ( 
 "+18005551212" 
 ); 
  
 printHash 
 ( 
 "John" 
 ); 
  
 printHash 
 ( 
 "Doe" 
 ); 
  
 } 
 } 
 

  package 
  
 updm.hashing 
 ; 
 import static 
  
 java.nio.charset.StandardCharsets.UTF_8 
 ; 
 import 
  
 java.security.MessageDigest 
 ; 
 import 
  
 java.security.NoSuchAlgorithmException 
 ; 
 import 
  
 java.util.Base64 
 ; 
 /** 
 * Example of the hashing algorithm. 
 * 
 * <p>Sample hashes: 
 * 
 * <ul> 
 *   <li>Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ= 
 *   <li>Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ= 
 *   <li>First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo= 
 *   <li>Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8= 
 * </ul> 
 */ 
 public 
  
 final 
  
 class 
 HashExample 
  
 { 
 private 
  
 HashExample 
 () 
  
 {} 
 public 
  
 static 
  
 String 
  
 hash 
 ( 
 String 
  
 token 
 ) 
  
 { 
  
 // Normalizes and hashes the input token using SHA-256 and Base64 encoding. 
  
 String 
  
 formattedToken 
  
 = 
  
 token 
 . 
 toLowerCase 
 (). 
 strip 
 (); 
  
 byte 
 [] 
  
 hash 
 ; 
  
 try 
  
 { 
  
 hash 
  
 = 
  
 MessageDigest 
 . 
 getInstance 
 ( 
 "SHA-256" 
 ). 
 digest 
 ( 
 formattedToken 
 . 
 getBytes 
 ( 
 UTF_8 
 )); 
  
 } 
  
 catch 
  
 ( 
 NoSuchAlgorithmException 
  
 e 
 ) 
  
 { 
  
 throw 
  
 new 
  
 IllegalStateException 
 ( 
 "SHA-256 not supported" 
 , 
  
 e 
 ); 
  
 } 
  
 return 
  
 Base64 
 . 
 getEncoder 
 (). 
 encodeToString 
 ( 
 hash 
 ); 
 } 
 public 
  
 static 
  
 void 
  
 printHash 
 ( 
 String 
  
 token 
 ) 
  
 { 
  
 // Calculates and prints the hash for the given token. 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
 "Hash: \"%s\"\t(Token: %s)\n" 
 , 
  
 hash 
 ( 
 token 
 ), 
  
 token 
 ); 
 } 
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 { 
  
 // Executes hash calculations and prints results for sample tokens. 
  
 printHash 
 ( 
 "test@gmail.com" 
 ); 
  
 printHash 
 ( 
 "+18005551212" 
 ); 
  
 printHash 
 ( 
 "John" 
 ); 
  
 printHash 
 ( 
 "Doe" 
 ); 
 } 
 } 
 

  /* 
 Provides the hashing algorithm, as well as some valid hashes of sample data for testing. 
 The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data. 
 Sample hashes: 
 - Email 'test@gmail.com': 87924606b4131a8aceeeae8868531fbb9712aaa07a5d3a756b26ce0f5d6ca674 
 - Phone '+18005551212':   61d9111bed3e6d9cfc1bc3b5cb35a402687c4f1546bee061a2bd444fbdd64c44 
 - First name 'John':      96d9632f363564cc3032521409cf22a852f2032eec099ed5967c0d000cec607a 
 - Last name 'Doe':        799ef92a11af918e3fb741df42934f3b568ed2d93ac1df74f1b8d41a27932a6f 
 The unhashed input table schema is assumed to be: 
 - Column name: UserID, Type: String 
 - Column name: Email, Type: String 
 - Column name: Phone, Type: String 
 - Column name: FirstName, Type: String 
 - Column name: LastName, Type: String 
 - Column name: PostalCode, Type: String 
 - Column name: CountryCode, Type: String 
 */ 
 -- Creates a new table with hashed versions of specified columns from the input table. 
 CREATE 
  
 TABLE 
  
 ` 
 your_project_name 
 . 
 your_dataset_name 
 . 
 output_hashed_table_name 
 ` 
 AS 
 SELECT 
  
 UserID 
 , 
  
 TO_HEX 
 ( 
 SHA256 
 ( 
 LOWER 
 ( 
 Email 
 ))) 
  
 AS 
  
 Email 
 , 
  
 TO_HEX 
 ( 
 SHA256 
 ( 
 Phone 
 )) 
  
 AS 
  
 Phone 
 , 
  
 TO_HEX 
 ( 
 SHA256 
 ( 
 LOWER 
 ( 
 FirstName 
 ))) 
  
 AS 
  
 FirstName 
 , 
  
 TO_HEX 
 ( 
 SHA256 
 ( 
 LOWER 
 ( 
 LastName 
 ))) 
  
 AS 
  
 LastName 
 , 
  
 PostalCode 
 , 
  
 CountryCode 
 , 
 FROM 
  
 ` 
 your_project_name 
 . 
 your_dataset_name 
 . 
 input_unhashed_table_name 
 ` 
 ; 
 

  /* 
 Provides the hashing algorithm, as well as some valid hashes of sample data for testing. 
 The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data. 
 Sample hashes: 
 - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ= 
 - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ= 
 - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo= 
 - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8= 
 The unhashed input table schema is assumed to be: 
 - Column name: UserID, Type: String 
 - Column name: Email, Type: String 
 - Column name: Phone, Type: String 
 - Column name: FirstName, Type: String 
 - Column name: LastName, Type: String 
 - Column name: PostalCode, Type: String 
 - Column name: CountryCode, Type: String 
 */ 
 -- Creates a new table with Base64-encoded SHA-256 hashes of specified columns. 
 CREATE 
  
 TABLE 
  
 ` 
 your_project_name 
 . 
 your_dataset_name 
 . 
 output_hashed_table_name 
 ` 
 AS 
 SELECT 
  
 UserID 
 , 
  
 TO_BASE64 
 ( 
 SHA256 
 ( 
 LOWER 
 ( 
 Email 
 ))) 
  
 AS 
  
 Email 
 , 
  
 TO_BASE64 
 ( 
 SHA256 
 ( 
 Phone 
 )) 
  
 AS 
  
 Phone 
 , 
  
 TO_BASE64 
 ( 
 SHA256 
 ( 
 LOWER 
 ( 
 FirstName 
 ))) 
  
 AS 
  
 FirstName 
 , 
  
 TO_BASE64 
 ( 
 SHA256 
 ( 
 LOWER 
 ( 
 LastName 
 ))) 
  
 AS 
  
 LastName 
 , 
  
 PostalCode 
 , 
  
 CountryCode 
 , 
 FROM 
  
 ` 
 your_project_name 
 . 
 your_dataset_name 
 . 
 input_unhashed_table_name 
 ` 
 ;