Using the Update API

importcom.google.cloud.webrisk.v1.WebRiskServiceClient ;
importcom.google.protobuf.ByteString ;
importcom.google.webrisk.v1.CompressionType ;
importcom.google.webrisk.v1.ComputeThreatListDiffRequest ;
importcom.google.webrisk.v1.ComputeThreatListDiffRequest.Constraints ;
importcom.google.webrisk.v1.ComputeThreatListDiffResponse ;
importcom.google.webrisk.v1.ThreatType ;
importjava.io.IOException;
publicclass ComputeThreatListDiff{
publicstaticvoidmain(String[]args)throwsIOException{
// TODO(developer): Replace these variables before running the sample.
// The threat list to update. Only a single ThreatType should be specified per request.
ThreatType threatType=ThreatType .MALWARE;
// The current version token of the client for the requested list. If the client does not have
// a version token (this is the first time calling ComputeThreatListDiff), this may be
// left empty and a full database snapshot will be returned.
ByteString versionToken=ByteString .EMPTY;
// The maximum size in number of entries. The diff will not contain more entries
// than this value. This should be a power of 2 between 2**10 and 2**20.
// If zero, no diff size limit is set.
intmaxDiffEntries=1024;
// Sets the maximum number of entries that the client is willing to have in the local database.
// This should be a power of 2 between 2**10 and 2**20. If zero, no database size limit is set.
intmaxDatabaseEntries=1024;
// The compression type supported by the client.
CompressionType compressionType=CompressionType .RAW;
computeThreatDiffList(threatType,versionToken,maxDiffEntries,maxDatabaseEntries,
compressionType);
}
// Gets the most recent threat list diffs. These diffs should be applied to a local database of
// hashes to keep it up-to-date.
// If the local database is empty or excessively out-of-date,
// a complete snapshot of the database will be returned. This Method only updates a
// single ThreatList at a time. To update multiple ThreatList databases, this method needs to be
// called once for each list.
publicstaticvoidcomputeThreatDiffList(ThreatType threatType,ByteString versionToken,
intmaxDiffEntries,intmaxDatabaseEntries,CompressionType compressionType)
throwsIOException{
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the `webRiskServiceClient.close()` method on the client to safely
// clean up any remaining background resources.
try(WebRiskServiceClient webRiskServiceClient=WebRiskServiceClient .create()){
Constraints constraints=Constraints .newBuilder()
.setMaxDiffEntries (maxDiffEntries)
.setMaxDatabaseEntries (maxDatabaseEntries)
.addSupportedCompressions (compressionType)
.build();
ComputeThreatListDiffResponse response=webRiskServiceClient.computeThreatListDiff(
ComputeThreatListDiffRequest .newBuilder()
.setThreatType (threatType)
.setVersionToken (versionToken)
.setConstraints (constraints)
.build());
// The returned response contains the following information:
// https://cloud.google.com/web-risk/docs/reference/rpc/google.cloud.webrisk.v1#computethreatlistdiffresponse
// Type of response: DIFF/ RESET/ RESPONSE_TYPE_UNSPECIFIED
System.out.println(response.getResponseType ());
// List of entries to add and/or remove.
// System.out.println(response.getAdditions());
// System.out.println(response.getRemovals());
// New version token to be used the next time when querying.
System.out.println(response.getNewVersionToken ());
// Recommended next diff timestamp.
System.out.println(response.getRecommendedNextDiff ());
System.out.println("Obtained threat list diff.");
}
}
}

fromgoogle.cloudimport webrisk_v1
fromgoogle.cloud.webrisk_v1import ComputeThreatListDiffResponse
defcompute_threatlist_diff(
 threat_type: webrisk_v1 .ThreatType ,
 version_token: bytes,
 max_diff_entries: int,
 max_database_entries: int,
 compression_type: webrisk_v1 .CompressionType ,
) -> ComputeThreatListDiffResponse:
"""Gets the most recent threat list diffs.
 These diffs should be applied to a local database of hashes to keep it up-to-date.
 If the local database is empty or excessively out-of-date,
 a complete snapshot of the database will be returned. This Method only updates a
 single ThreatList at a time. To update multiple ThreatList databases, this method needs to be
 called once for each list.
 Args:
 threat_type: The threat list to update. Only a single ThreatType should be specified per request.
 threat_type = webrisk_v1.ThreatType.MALWARE
 version_token: The current version token of the client for the requested list. If the
 client does not have a version token (this is the first time calling ComputeThreatListDiff),
 this may be left empty and a full database snapshot will be returned.
 max_diff_entries: The maximum size in number of entries. The diff will not contain more entries
 than this value. This should be a power of 2 between 2**10 and 2**20.
 If zero, no diff size limit is set.
 max_diff_entries = 1024
 max_database_entries: Sets the maximum number of entries that the client is willing to have in the local database.
 This should be a power of 2 between 2**10 and 2**20. If zero, no database size limit is set.
 max_database_entries = 1024
 compression_type: The compression type supported by the client.
 compression_type = webrisk_v1.CompressionType.RAW
 Returns:
 The response which contains the diff between local and remote threat lists. In addition to the threat list,
 the response also contains the version token and the recommended time for next diff.
 """
 webrisk_client = webrisk_v1 .WebRiskServiceClient ()
 constraints = webrisk_v1 .ComputeThreatListDiffRequest .Constraints ()
 constraints.max_diff_entries = max_diff_entries
 constraints.max_database_entries = max_database_entries
 constraints.supported_compressions = [compression_type]
 request = webrisk_v1 .ComputeThreatListDiffRequest ()
 request.threat_type = threat_type
 request.version_token = version_token
 request.constraints = constraints
 response = webrisk_client.compute_threat_list_diff (request)
 # The returned response contains the following information:
 # https://cloud.google.com/web-risk/docs/reference/rpc/google.cloud.webrisk.v1#computethreatlistdiffresponse
 # Type of response: DIFF/ RESET/ RESPONSE_TYPE_UNSPECIFIED
 print(response.response_type)
 # New version token to be used the next time when querying.
 print(response.new_version_token)
 # Recommended next diff timestamp.
 print(response.recommended_next_diff)
 return response

importcom.google.cloud.webrisk.v1.WebRiskServiceClient ;
importcom.google.protobuf.ByteString ;
importcom.google.webrisk.v1.SearchHashesRequest ;
importcom.google.webrisk.v1.SearchHashesResponse ;
importcom.google.webrisk.v1.SearchHashesResponse.ThreatHash ;
importcom.google.webrisk.v1.ThreatType ;
importjava.io.IOException;
importjava.nio.charset.StandardCharsets;
importjava.security.MessageDigest;
importjava.security.NoSuchAlgorithmException;
importjava.util.Arrays;
importjava.util.Base64;
importjava.util.List;
publicclass SearchHashes{
publicstaticvoidmain(String[]args)throwsIOException,NoSuchAlgorithmException{
// TODO(developer): Replace these variables before running the sample.
// A hash prefix, consisting of the most significant 4-32 bytes of a SHA256 hash.
// For JSON requests, this field is base64-encoded. Note that if this parameter is provided
// by a URI, it must be encoded using the web safe base64 variant (RFC 4648).
Stringuri="http://example.com";
StringencodedUri=Base64.getUrlEncoder().encodeToString(uri.getBytes(StandardCharsets.UTF_8));
MessageDigestdigest=MessageDigest.getInstance("SHA-256");
byte[]encodedHashPrefix=digest.digest(encodedUri.getBytes(StandardCharsets.UTF_8));
// The ThreatLists to search in. Multiple ThreatLists may be specified.
// For the list on threat types, see: https://cloud.google.com/web-risk/docs/reference/rpc/google.cloud.webrisk.v1#threattype
List<ThreatType>threatTypes=Arrays.asList(ThreatType .MALWARE,ThreatType .SOCIAL_ENGINEERING);
searchHash(ByteString .copyFrom (encodedHashPrefix),threatTypes);
}
// Gets the full hashes that match the requested hash prefix.
// This is used after a hash prefix is looked up in a threatList and there is a match.
// The client side threatList only holds partial hashes so the client must query this method
// to determine if there is a full hash match of a threat.
publicstaticvoidsearchHash(ByteString encodedHashPrefix,List<ThreatType>threatTypes)
throwsIOException{
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the `webRiskServiceClient.close()` method on the client to safely
// clean up any remaining background resources.
try(WebRiskServiceClient webRiskServiceClient=WebRiskServiceClient .create()){
// Set the hashPrefix and the threat types to search in.
SearchHashesResponse response=webRiskServiceClient.searchHashes(
SearchHashesRequest .newBuilder()
.setHashPrefix (encodedHashPrefix)
.addAllThreatTypes(threatTypes)
.build());
// Get all the hashes that match the prefix. Cache the returned hashes until the time
// specified in threatHash.getExpireTime()
// For more information on response type, see: https://cloud.google.com/web-risk/docs/reference/rpc/google.cloud.webrisk.v1#threathash
for(ThreatHash threatHash:response.getThreatsList ()){
System.out.println(threatHash.getHash());
}
System.out.println("Completed searching threat hashes.");
}
}
}

fromgoogle.cloudimport webrisk_v1
defsearch_hashes(hash_prefix: bytes, threat_type: webrisk_v1 .ThreatType ) -> list:
"""Gets the full hashes that match the requested hash prefix.
 This is used after a hash prefix is looked up in a threatList and there is a match.
 The client side threatList only holds partial hashes so the client must query this method
 to determine if there is a full hash match of a threat.
 Args:
 hash_prefix: A hash prefix, consisting of the most significant 4-32 bytes of a SHA256 hash.
 For JSON requests, this field is base64-encoded. Note that if this parameter is provided
 by a URI, it must be encoded using the web safe base64 variant (RFC 4648).
 Example:
 uri = "http://example.com"
 sha256 = sha256()
 sha256.update(base64.urlsafe_b64encode(bytes(uri, "utf-8")))
 hex_string = sha256.digest()
 threat_type: The ThreatLists to search in. Multiple ThreatLists may be specified.
 For the list on threat types, see:
 https://cloud.google.com/web-risk/docs/reference/rpc/google.cloud.webrisk.v1#threattype
 threat_type = [webrisk_v1.ThreatType.MALWARE, webrisk_v1.ThreatType.SOCIAL_ENGINEERING]
 Returns:
 A hash list that contain all hashes that matches the given hash prefix.
 """
 webrisk_client = webrisk_v1 .WebRiskServiceClient ()
 # Set the hashPrefix and the threat types to search in.
 request = webrisk_v1 .SearchHashesRequest ()
 request.hash_prefix = hash_prefix
 request.threat_types = [threat_type]
 response = webrisk_client.search_hashes (request)
 # Get all the hashes that match the prefix. Cache the returned hashes until the time
 # specified in threat_hash.expire_time
 # For more information on response type, see:
 # https://cloud.google.com/web-risk/docs/reference/rpc/google.cloud.webrisk.v1#threathash
 hash_list = []
 for threat_hash in response.threats:
 hash_list.append(threat_hash.hash)
 return hash_list