501 lines
11 KiB
Go
501 lines
11 KiB
Go
/*
|
|
|--------------------------------------------------------------------------
|
|
| Manifest
|
|
|--------------------------------------------------------------------------
|
|
|
|
|
| Name:
|
|
| - Marker
|
|
|
|
|
| Purpose:
|
|
| - Provide a unified utility for generating unique markers through
|
|
| time-based, random, and encoded generation strategies.
|
|
|
|
|
| Guideline:
|
|
| - Use ObrimMarker as the single entry point.
|
|
| - Validate marker type before processing.
|
|
| - Maintain standardized response structures.
|
|
| - Use isolated workflows for each marker type.
|
|
| - Support future marker extensions without modifying existing workflows.
|
|
|
|
|
| Example:
|
|
| - ObrimMarker("time", map[string]any{})
|
|
| - ObrimMarker("random", map[string]any{"length":16})
|
|
| - ObrimMarker("encoded", map[string]any{"data":"example"})
|
|
|
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
/*
|
|
|--------------------------------------------------------------------------
|
|
| Credit
|
|
|--------------------------------------------------------------------------
|
|
|
|
|
| Contributor:
|
|
| - Rajon Ahmed
|
|
| - Scionite
|
|
|
|
|
|--------------------------------------------------------------------------
|
|
*/
|
|
|
|
package marker
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"math"
|
|
"strings"
|
|
"time"
|
|
|
|
"go/module/essential/visible/service/helper/log"
|
|
"go/module/essential/visible/service/helper/status"
|
|
)
|
|
|
|
const (
|
|
obrimMarkerTypeTime = "time"
|
|
obrimMarkerTypeRandom = "random"
|
|
obrimMarkerTypeEncoded = "encoded"
|
|
|
|
obrimMarkerDefaultEpoch int64 = 0
|
|
obrimMarkerDefaultLength int = 16
|
|
|
|
obrimMarkerDefaultCharset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
|
)
|
|
|
|
// ObrimMarker routes marker generation requests and returns a standardized marker response.
|
|
func ObrimMarker(markerType string, config map[string]any) map[string]any {
|
|
log.ObrimLog("INIT", "Marker utility initialized.")
|
|
status.ObrimStatus("INFO", "Processing marker generation request.")
|
|
|
|
if !obrimMarkerValidateType(markerType) {
|
|
log.ObrimLog("ERROR", "Unsupported marker type.")
|
|
status.ObrimStatus("ERROR", "Unsupported marker type.")
|
|
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_UNSUPPORTED_TYPE",
|
|
nil,
|
|
)
|
|
}
|
|
|
|
response := obrimMarkerRoute(markerType, config)
|
|
|
|
if statusValue, ok := response["status"].(bool); ok && statusValue {
|
|
log.ObrimLog("SUCCESS", "Marker generated successfully.")
|
|
status.ObrimStatus("SUCCESS", "Marker generated successfully.")
|
|
} else {
|
|
log.ObrimLog("ERROR", "Marker generation failed.")
|
|
status.ObrimStatus("ERROR", "Marker generation failed.")
|
|
}
|
|
|
|
return response
|
|
}
|
|
|
|
// obrimMarkerValidateType validates supported marker generation types.
|
|
func obrimMarkerValidateType(markerType string) bool {
|
|
switch markerType {
|
|
case obrimMarkerTypeTime,
|
|
obrimMarkerTypeRandom,
|
|
obrimMarkerTypeEncoded:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// obrimMarkerRoute routes execution to the selected marker generation workflow.
|
|
func obrimMarkerRoute(markerType string, config map[string]any) map[string]any {
|
|
switch markerType {
|
|
case obrimMarkerTypeTime:
|
|
return obrimMarkerTime(config)
|
|
|
|
case obrimMarkerTypeRandom:
|
|
return obrimMarkerRandom(config)
|
|
|
|
case obrimMarkerTypeEncoded:
|
|
return obrimMarkerEncoded(config)
|
|
|
|
default:
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_UNSUPPORTED_TYPE",
|
|
nil,
|
|
)
|
|
}
|
|
}
|
|
|
|
// obrimMarkerBuildResponse builds standardized success and error responses.
|
|
func obrimMarkerBuildResponse(
|
|
statusValue bool,
|
|
code string,
|
|
payload any,
|
|
) map[string]any {
|
|
return map[string]any{
|
|
"status": statusValue,
|
|
"code": code,
|
|
"payload": payload,
|
|
}
|
|
}
|
|
|
|
// obrimMarkerTime generates time-based unique markers.
|
|
func obrimMarkerTime(config map[string]any) map[string]any {
|
|
if err := obrimMarkerValidateTime(config); err != nil {
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_VALIDATION",
|
|
nil,
|
|
)
|
|
}
|
|
|
|
// Mutable variable storing effective epoch.
|
|
var epoch int64 = obrimMarkerDefaultEpoch
|
|
|
|
if value, ok := config["epoch"]; ok {
|
|
switch typed := value.(type) {
|
|
case int64:
|
|
epoch = typed
|
|
case int:
|
|
epoch = int64(typed)
|
|
case float64:
|
|
epoch = int64(typed)
|
|
}
|
|
}
|
|
|
|
// Mutable variable storing instance identifier.
|
|
var instance string
|
|
|
|
if value, ok := config["instance"].(string); ok {
|
|
instance = value
|
|
}
|
|
|
|
marker, err := obrimMarkerTimeGenerate(epoch, instance)
|
|
if err != nil {
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_GENERATION",
|
|
nil,
|
|
)
|
|
}
|
|
|
|
payload := map[string]any{
|
|
"marker": marker,
|
|
"epoch": epoch,
|
|
"instance": instance,
|
|
}
|
|
|
|
return obrimMarkerBuildResponse(
|
|
true,
|
|
"SUCCESS_TIME_GENERATED",
|
|
payload,
|
|
)
|
|
}
|
|
|
|
// obrimMarkerValidateTime validates time marker configuration parameters.
|
|
func obrimMarkerValidateTime(config map[string]any) error {
|
|
if value, ok := config["epoch"]; ok {
|
|
switch typed := value.(type) {
|
|
case int64:
|
|
if typed < 0 {
|
|
return fmt.Errorf("invalid epoch")
|
|
}
|
|
case int:
|
|
if typed < 0 {
|
|
return fmt.Errorf("invalid epoch")
|
|
}
|
|
case float64:
|
|
if typed < 0 {
|
|
return fmt.Errorf("invalid epoch")
|
|
}
|
|
default:
|
|
return fmt.Errorf("invalid epoch type")
|
|
}
|
|
}
|
|
|
|
if value, ok := config["instance"]; ok {
|
|
instance, valid := value.(string)
|
|
if !valid || strings.TrimSpace(instance) == "" {
|
|
return fmt.Errorf("invalid instance")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// obrimMarkerTimeGenerate produces the final time-based marker value.
|
|
func obrimMarkerTimeGenerate(epoch int64, instance string) (string, error) {
|
|
// Mutable variable storing current timestamp.
|
|
var currentTimestamp int64 = time.Now().UnixMilli()
|
|
|
|
// Mutable variable storing relative timestamp.
|
|
var relativeTimestamp int64 = currentTimestamp - epoch
|
|
|
|
if relativeTimestamp < 0 {
|
|
return "", fmt.Errorf("invalid timestamp")
|
|
}
|
|
|
|
source := fmt.Sprintf("%d:%s", relativeTimestamp, instance)
|
|
|
|
hash := sha256.Sum256([]byte(source))
|
|
|
|
return strings.ToUpper(base64.RawURLEncoding.EncodeToString(hash[:])), nil
|
|
}
|
|
|
|
// obrimMarkerRandom generates random collision-resistant markers.
|
|
func obrimMarkerRandom(config map[string]any) map[string]any {
|
|
if err := obrimMarkerValidateRandom(config); err != nil {
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_VALIDATION",
|
|
nil,
|
|
)
|
|
}
|
|
|
|
// Mutable variable storing desired length.
|
|
var length int = obrimMarkerDefaultLength
|
|
|
|
if value, ok := config["length"]; ok {
|
|
switch typed := value.(type) {
|
|
case int:
|
|
length = typed
|
|
case int64:
|
|
length = int(typed)
|
|
case float64:
|
|
length = int(typed)
|
|
}
|
|
}
|
|
|
|
// Mutable variable storing charset.
|
|
var charset string = obrimMarkerDefaultCharset
|
|
|
|
if value, ok := config["charset"].(string); ok {
|
|
charset = value
|
|
}
|
|
|
|
marker, err := obrimMarkerRandomGenerate(length, charset)
|
|
if err != nil {
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_GENERATION",
|
|
nil,
|
|
)
|
|
}
|
|
|
|
payload := map[string]any{
|
|
"marker": marker,
|
|
"length": length,
|
|
"charset": charset,
|
|
}
|
|
|
|
return obrimMarkerBuildResponse(
|
|
true,
|
|
"SUCCESS_RANDOM_GENERATED",
|
|
payload,
|
|
)
|
|
}
|
|
|
|
// obrimMarkerValidateRandom validates random marker configuration parameters.
|
|
func obrimMarkerValidateRandom(config map[string]any) error {
|
|
if value, ok := config["length"]; ok {
|
|
switch typed := value.(type) {
|
|
case int:
|
|
if typed <= 0 {
|
|
return fmt.Errorf("invalid length")
|
|
}
|
|
case int64:
|
|
if typed <= 0 {
|
|
return fmt.Errorf("invalid length")
|
|
}
|
|
case float64:
|
|
if typed <= 0 {
|
|
return fmt.Errorf("invalid length")
|
|
}
|
|
default:
|
|
return fmt.Errorf("invalid length type")
|
|
}
|
|
}
|
|
|
|
if value, ok := config["charset"]; ok {
|
|
charset, valid := value.(string)
|
|
|
|
if !valid || len(charset) == 0 {
|
|
return fmt.Errorf("invalid charset")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// obrimMarkerRandomGenerate produces the final random marker value.
|
|
func obrimMarkerRandomGenerate(length int, charset string) (string, error) {
|
|
// Mutable variable storing generated marker bytes.
|
|
var markerBuilder strings.Builder
|
|
|
|
charsetLength := len(charset)
|
|
|
|
for index := 0; index < length; index++ {
|
|
randomIndex, err := obrimMarkerRandomIndex(charsetLength)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
markerBuilder.WriteByte(charset[randomIndex])
|
|
}
|
|
|
|
return markerBuilder.String(), nil
|
|
}
|
|
|
|
// obrimMarkerRandomIndex generates a secure random index.
|
|
func obrimMarkerRandomIndex(limit int) (int, error) {
|
|
randomBytes := make([]byte, 8)
|
|
|
|
if _, err := rand.Read(randomBytes); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
randomValue := binary.BigEndian.Uint64(randomBytes)
|
|
|
|
return int(randomValue % uint64(limit)), nil
|
|
}
|
|
|
|
// obrimMarkerEncoded generates deterministic encoded markers.
|
|
func obrimMarkerEncoded(config map[string]any) map[string]any {
|
|
if err := obrimMarkerValidateEncoded(config); err != nil {
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_VALIDATION",
|
|
nil,
|
|
)
|
|
}
|
|
|
|
source := config["data"].(string)
|
|
|
|
// Mutable variable storing desired length.
|
|
var length int = obrimMarkerDefaultLength
|
|
|
|
if value, ok := config["length"]; ok {
|
|
switch typed := value.(type) {
|
|
case int:
|
|
length = typed
|
|
case int64:
|
|
length = int(typed)
|
|
case float64:
|
|
length = int(typed)
|
|
}
|
|
}
|
|
|
|
// Mutable variable storing charset.
|
|
var charset string = obrimMarkerDefaultCharset
|
|
|
|
if value, ok := config["charset"].(string); ok {
|
|
charset = value
|
|
}
|
|
|
|
// Mutable variable storing optional salt.
|
|
var salt string
|
|
|
|
if value, ok := config["salt"].(string); ok {
|
|
salt = value
|
|
}
|
|
|
|
marker, err := obrimMarkerEncodedGenerate(
|
|
source,
|
|
length,
|
|
charset,
|
|
salt,
|
|
)
|
|
|
|
if err != nil {
|
|
return obrimMarkerBuildResponse(
|
|
false,
|
|
"FAILED_GENERATION",
|
|
nil,
|
|
)
|
|
}
|
|
|
|
payload := map[string]any{
|
|
"marker": marker,
|
|
"source": source,
|
|
"length": length,
|
|
}
|
|
|
|
return obrimMarkerBuildResponse(
|
|
true,
|
|
"SUCCESS_ENCODED_GENERATED",
|
|
payload,
|
|
)
|
|
}
|
|
|
|
// obrimMarkerValidateEncoded validates encoded marker configuration parameters.
|
|
func obrimMarkerValidateEncoded(config map[string]any) error {
|
|
data, ok := config["data"].(string)
|
|
|
|
if !ok || strings.TrimSpace(data) == "" {
|
|
return fmt.Errorf("invalid data")
|
|
}
|
|
|
|
if value, ok := config["length"]; ok {
|
|
switch typed := value.(type) {
|
|
case int:
|
|
if typed <= 0 {
|
|
return fmt.Errorf("invalid length")
|
|
}
|
|
case int64:
|
|
if typed <= 0 {
|
|
return fmt.Errorf("invalid length")
|
|
}
|
|
case float64:
|
|
if typed <= 0 {
|
|
return fmt.Errorf("invalid length")
|
|
}
|
|
default:
|
|
return fmt.Errorf("invalid length type")
|
|
}
|
|
}
|
|
|
|
if value, ok := config["charset"]; ok {
|
|
charset, valid := value.(string)
|
|
|
|
if !valid || len(charset) == 0 {
|
|
return fmt.Errorf("invalid charset")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// obrimMarkerEncodedGenerate produces the final encoded marker value.
|
|
func obrimMarkerEncodedGenerate(
|
|
source string,
|
|
length int,
|
|
charset string,
|
|
salt string,
|
|
) (string, error) {
|
|
hash := sha256.Sum256([]byte(source + salt))
|
|
|
|
charsetLength := len(charset)
|
|
|
|
if charsetLength == 0 {
|
|
return "", fmt.Errorf("invalid charset")
|
|
}
|
|
|
|
// Mutable variable storing generated marker bytes.
|
|
var markerBuilder strings.Builder
|
|
|
|
for _, value := range hash {
|
|
index := int(math.Abs(float64(value))) % charsetLength
|
|
markerBuilder.WriteByte(charset[index])
|
|
|
|
if markerBuilder.Len() >= length {
|
|
break
|
|
}
|
|
}
|
|
|
|
for markerBuilder.Len() < length {
|
|
markerBuilder.WriteByte(charset[0])
|
|
}
|
|
|
|
return markerBuilder.String(), nil
|
|
}
|