Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
ruanhaishen
Acme.Sh
Commits
d66c430e
Commit
d66c430e
authored
Aug 26, 2020
by
Ed Lynes
Browse files
debugging and cleanup
parent
a674e410
Changes
1
Show whitespace changes
Inline
Side-by-side
dnsapi/dns_edgedns.sh
View file @
d66c430e
...
@@ -29,9 +29,7 @@ ACME_EDGEDNS_VERSION="0.1.0"
...
@@ -29,9 +29,7 @@ ACME_EDGEDNS_VERSION="0.1.0"
dns_edgedns_add
()
{
dns_edgedns_add
()
{
fulldomain
=
$1
fulldomain
=
$1
txtvalue
=
$2
txtvalue
=
$2
_debug
"ENTERING DNS_EDGEDNS_ADD"
_debug
"ENTERING DNS_EDGEDNS_ADD"
_debug2
"fulldomain"
"
$fulldomain
"
_debug2
"fulldomain"
"
$fulldomain
"
_debug2
"txtvalue"
"
$txtvalue
"
_debug2
"txtvalue"
"
$txtvalue
"
...
@@ -39,44 +37,53 @@ dns_edgedns_add() {
...
@@ -39,44 +37,53 @@ dns_edgedns_add() {
_err
"
$@
"
_err
"
$@
"
return
1
return
1
fi
fi
if
!
_EDGEDNS_getZoneInfo
"
$fulldomain
"
;
then
if
!
_EDGEDNS_getZoneInfo
"
$fulldomain
"
;
then
_err
"Invalid domain"
_err
"Invalid domain"
return
1
return
1
fi
fi
_debug2
"Add: zone"
"
$
{
zone
}
"
_debug2
"Add: zone"
"
$zone
"
acmeRecordURI
=
$(
printf
"%s/%s/names/%s/type/TXT"
"
$
{
edge_endpoint
}
"
"
$
{
zone
}
"
"
$
{
fulldomain
}
"
)
acmeRecordURI
=
$(
printf
"%s/%s/names/%s/type
s
/TXT"
"
$edge_endpoint
"
"
$zone
"
"
$fulldomain
"
)
_debug3
"Add URL"
"
$acmeRecordURI
"
_debug3
"Add URL"
"
$acmeRecordURI
"
# Get existing TXT record
# Get existing TXT record
_edge_result
=
$(
_edgedns_rest GET
"
$acmeRecordURI
"
)
_edge_result
=
$(
_edgedns_rest GET
"
$acmeRecordURI
"
)
_api_status
=
"
$?
"
_api_status
=
"
$?
"
if
[
"
$_api_status
"
-ne
0
]
&&
[
"
$_edge_result
"
!=
"404"
]
;
then
_debug3
"_edge_result"
"
$_edge_result
"
if
[
"
$_api_status
"
-ne
0
]
;
then
if
[
"
$curResult
"
=
"FATAL"
]
;
then
_err
"
$(
printf
"Fatal error: acme API function call : %s"
"
$retVal
"
)
"
fi
if
[
"
$_edge_result
"
!=
"404"
]
;
then
_err
"
$(
printf
"Failure accessing Akamai Edge DNS API Server. Error: %s"
"
$_edge_result
"
)
"
_err
"
$(
printf
"Failure accessing Akamai Edge DNS API Server. Error: %s"
"
$_edge_result
"
)
"
return
1
return
1
fi
fi
rdata
=
"
\"
$txtvalue
\"
"
fi
rdata
=
"
\"
${
txtvalue
}
\"
"
record_op
=
"POST"
record_op
=
"POST"
if
[
"
$_api_status
"
-eq
0
]
;
then
if
[
"
$_api_status
"
-eq
0
]
;
then
# record already exists. Get existing record data and update
# record already exists. Get existing record data and update
record_op
=
"PUT"
record_op
=
"PUT"
rdlist
=
$(
echo
-n
"
$response
"
| _egrep_o
"
\"
rdata
\"\\
s*:
\\
s*
\\
[
\\
s*
\"
[^
\"
]*
\"\\
s*]"
|
cut
-d
:
-f
2 |
tr
-d
"[]
\"
"
)
rdlist
=
"
${
_edge_result
#*\
"rdata
\"
:[}"
_debug2
"existing TXT found"
rdlist=
"
${
rdlist
%%]*
}
"
_debug2
"record data"
"
$rdlist
"
rdlist=
$(
echo
"
$rdlist
"
|
tr
-d
'"'
|
tr
-d
"
\\
"
)
_debug3
"existing TXT found"
_debug3
"record data"
"
$rdlist
"
# value already there?
# value already there?
if _contains
"
$rdlist
"
"
$txtvalue
"
; then
if _contains
"
$rdlist
"
"
$txtvalue
"
; then
return 0
return 0
fi
fi
comma
=
","
_txt_val=
""
rdata
=
"
$rdata$comma
\"
${
txtvalue
}
\"
"
while [
"
$_txt_val
"
!=
"
$rdlist
"
] && [
"
${
rdlist
}
"
]; do
_txt_val=
"
${
rdlist
%%,*
}
"
; rdlist=
"
${
rdlist
#*,
}
"
rdata=
"
${
rdata
}
,
\"
${
_txt_val
}
\"
"
done
fi
fi
_debug2
"new/updated rdata: "
"
${
rdata
}
"
# Add the txtvalue TXT Record
# Add the txtvalue TXT Record
body=
"{
\"
name
\"
:
\"
$fulldomain
\"
,
\"
type
\"
:
\"
TXT
\"
,
\"
ttl
\"
:600,
\"
rdata
\"
:"
[
${
rdata
}
]
"}"
body=
"{
\"
name
\"
:
\"
$fulldomain
\"
,
\"
type
\"
:
\"
TXT
\"
,
\"
ttl
\"
:600,
\"
rdata
\"
:"
[
${
rdata
}
]
"}"
_debug3
"Add body '
${
body
}
'"
_debug3
"Add body '
${
body
}
'"
_edge_result=
$(
_edgedns_rest
"
$record_op
"
"
$acmeRecordURI
"
"
$body
"
)
_edge_result=
$(
_edgedns_rest
"
$record_op
"
"
$acmeRecordURI
"
"
$body
"
)
_api_status=
"
$?
"
_api_status=
"
$?
"
if [
"
$_api_status
"
-eq 0 ]; then
if [
"
$_api_status
"
-eq 0 ]; then
_log
"
$(
printf
"Text value %s added to recordset %s"
"
$
{
txtvalue
}
"
"
$
{
fulldomain
}
"
)
"
_log
"
$(
printf
"Text value %s added to recordset %s"
"
$txtvalue
"
"
$fulldomain
"
)
"
return 0
return 0
else
else
_err
"
$(
printf
"error adding TXT record for validation. Error: %s"
"
$_edge_result
"
)
"
_err
"
$(
printf
"error adding TXT record for validation. Error: %s"
"
$_edge_result
"
)
"
...
@@ -84,20 +91,89 @@ dns_edgedns_add() {
...
@@ -84,20 +91,89 @@ dns_edgedns_add() {
fi
fi
}
}
# Usage: dns_edgedns_rm _acme-challenge.www.domain.com
# Usage: dns_edgedns_rm _acme-challenge.www.domain.com
"
XKrxpRBosdIKFzxW_CT3KLZNf6q0HG9i01zxXp5CPBs
"
# Used to delete txt record
# Used to delete txt record
#
#
dns_edgedns_rm() {
dns_edgedns_rm() {
fulldomain=
$1
fulldomain=
$1
txtvalue=
$2
_debug "
ENTERING DNS_EDGEDNS_RM
"
_debug2 "
fulldomain
" "
$fulldomain
"
_debug2 "
txtvalue
" "
$txtvalue
"
if ! _EDGEDNS_credentials; then
_err "
$@
"
return 1
fi
if ! _EDGEDNS_getZoneInfo "
$fulldomain
"; then
_err "
Invalid domain
"
return 1
fi
_debug2 "
RM: zone
" "
${
zone
}
"
acmeRecordURI=
$(
printf
"%s/%s/names/%s/types/TXT"
"
${
edge_endpoint
}
"
"
$zone
"
"
$fulldomain
"
)
_debug3 "
RM URL
" "
$acmeRecordURI
"
# Get existing TXT record
_edge_result=
$(
_edgedns_rest GET
"
$acmeRecordURI
"
)
_api_status="
$?
"
if [ "
$_api_status
" -ne 0 ]; then
if [ "
$curResult
" = "
FATAL
" ]; then
_err "
$(
printf
"Fatal error: acme API function call : %s"
"
$retVal
"
)
"
fi
if [ "
$_edge_result
" != "
404
" ]; then
_err "
$(
printf
"Failure accessing Akamai Edge DNS API Server. Error: %s"
"
$_edge_result
"
)
"
return 1
fi
fi
_debug3 "
_edge_result
" "
$_edge_result
"
record_op="
DELETE
"
body=""
if [ "
$_api_status
" -eq 0 ]; then
# record already exists. Get existing record data and update
rdlist="
${
_edge_result
#*\
"rdata
\"
:[}"
rdlist=
"
${
rdlist
%%]*
}
"
rdlist=
$(
echo
"
$rdlist
"
|
tr
-d
'"'
|
tr
-d
"
\\
"
)
_debug3
"rdlist"
"
$rdlist
"
if [ -n
"
$rdlist
"
]; then
record_op=
"PUT"
comma=
""
rdata=
""
_txt_val=
""
while [
"
$_txt_val
"
!=
"
$rdlist
"
] && [
"
$rdlist
"
]; do
_txt_val=
"
${
rdlist
%%,*
}
"
; rdlist=
"
${
rdlist
#*,
}
"
_debug3
"_txt_val"
"
$_txt_val
"
_debug3
"txtvalue"
"
$txtvalue
"
if ! _contains
"
$_txt_val
"
"
$txtvalue
"
; then
rdata=
"
${
rdata
}${
comma
}
\"
${
_txt_val
}
\"
"
comma=
","
fi
done
if [ -z
"
$rdata
"
]; then
record_op=
"DELETE"
else
# Recreate the txtvalue TXT Record
body=
"{
\"
name
\"
:
\"
$fulldomain
\"
,
\"
type
\"
:
\"
TXT
\"
,
\"
ttl
\"
:600,
\"
rdata
\"
:"
[
${
rdata
}
]
"}"
_debug3
"body"
"
$body
"
fi
fi
fi
_edge_result=
$(
_edgedns_rest
"
$record_op
"
"
$acmeRecordURI
"
"
$body
"
)
_api_status=
"
$?
"
if [
"
$_api_status
"
-eq 0 ]; then
_log
"
$(
printf
"Text value %s removed from recordset %s"
"
$txtvalue
"
"
$fulldomain
"
)
"
return 0
else
_err
"
$(
printf
"error removing TXT record for validation. Error: %s"
"
$_edge_result
"
)
"
return 1
fi
}
}
#################### Private functions below ##################################
#################### Private functions below ##################################
_EDGEDNS_credentials
()
{
_EDGEDNS_credentials
()
{
_debug
"GettingEdge DNS credentials"
_debug
"GettingEdge DNS credentials"
_log
$(
printf
"ACME DNSAPI Edge DNS version %s"
${
ACME_EDGEDNS_VERSION
}
)
_log
"
$(
printf
"ACME DNSAPI Edge DNS version %s"
${
ACME_EDGEDNS_VERSION
}
)
"
args_missing
=
0
args_missing
=
0
if
[
-z
"
$
{
AKAMAI_ACCESS_TOKEN
}
"
]
;
then
if
[
-z
"
$AKAMAI_ACCESS_TOKEN
"
]
;
then
AKAMAI_ACCESS_TOKEN
=
""
AKAMAI_ACCESS_TOKEN
=
""
AKAMAI_CLIENT_TOKEN
=
""
AKAMAI_CLIENT_TOKEN
=
""
AKAMAI_HOST
=
""
AKAMAI_HOST
=
""
...
@@ -113,7 +189,7 @@ _EDGEDNS_credentials() {
...
@@ -113,7 +189,7 @@ _EDGEDNS_credentials() {
_err
"AKAMAI_CLIENT_TOKEN is missing"
_err
"AKAMAI_CLIENT_TOKEN is missing"
args_missing
=
1
args_missing
=
1
fi
fi
if
[
-z
"
$
{
AKAMAI_HOST
}
"
]
;
then
if
[
-z
"
$AKAMAI_HOST
"
]
;
then
AKAMAI_ACCESS_TOKEN
=
""
AKAMAI_ACCESS_TOKEN
=
""
AKAMAI_CLIENT_TOKEN
=
""
AKAMAI_CLIENT_TOKEN
=
""
AKAMAI_HOST
=
""
AKAMAI_HOST
=
""
...
@@ -121,7 +197,7 @@ _EDGEDNS_credentials() {
...
@@ -121,7 +197,7 @@ _EDGEDNS_credentials() {
_err
"AKAMAI_HOST is missing"
_err
"AKAMAI_HOST is missing"
args_missing
=
1
args_missing
=
1
fi
fi
if
[
-z
"
$
{
AKAMAI_CLIENT_SECRET
}
"
]
;
then
if
[
-z
"
$AKAMAI_CLIENT_SECRET
"
]
;
then
AKAMAI_ACCESS_TOKEN
=
""
AKAMAI_ACCESS_TOKEN
=
""
AKAMAI_CLIENT_TOKEN
=
""
AKAMAI_CLIENT_TOKEN
=
""
AKAMAI_HOST
=
""
AKAMAI_HOST
=
""
...
@@ -130,19 +206,19 @@ _EDGEDNS_credentials() {
...
@@ -130,19 +206,19 @@ _EDGEDNS_credentials() {
args_missing
=
1
args_missing
=
1
fi
fi
if
[
"
$
{
args_missing
}
"
=
1
]
;
then
if
[
"
$args_missing
"
=
1
]
;
then
_err
"You have not properly specified the EdgeDNS Open Edgegrid API credentials. Please try again."
_err
"You have not properly specified the EdgeDNS Open Edgegrid API credentials. Please try again."
return
1
return
1
else
else
_saveaccountconf_mutable AKAMAI_ACCESS_TOKEN
"
$
{
AKAMAI_ACCESS_TOKEN
}
"
_saveaccountconf_mutable AKAMAI_ACCESS_TOKEN
"
$AKAMAI_ACCESS_TOKEN
"
_saveaccountconf_mutable AKAMAI_CLIENT_TOKEN
"
$
{
AKAMAI_CLIENT_TOKEN
}
"
_saveaccountconf_mutable AKAMAI_CLIENT_TOKEN
"
$AKAMAI_CLIENT_TOKEN
"
_saveaccountconf_mutable AKAMAI_HOST
"
$
{
AKAMAI_HOST
}
"
_saveaccountconf_mutable AKAMAI_HOST
"
$AKAMAI_HOST
"
_saveaccountconf_mutable AKAMAI_CLIENT_SECRET
"
$
{
AKAMAI_CLIENT_SECRET
}
"
_saveaccountconf_mutable AKAMAI_CLIENT_SECRET
"
$AKAMAI_CLIENT_SECRET
"
# Set whether curl should use secure or insecure mode
# Set whether curl should use secure or insecure mode
fi
fi
export
HTTPS_INSECURE
=
0
# All Edgegrid API calls are secure
export
HTTPS_INSECURE
=
0
# All Edgegrid API calls are secure
edge_endpoint
=
$(
printf
"https://%s/config-dns/v2/zones"
"
$
{
AKAMAI_HOST
}
"
)
edge_endpoint
=
$(
printf
"https://%s/config-dns/v2/zones"
"
$AKAMAI_HOST
"
)
_debug3
"Edge API Endpoint:"
"
$
{
edge_endpoint
}
"
_debug3
"Edge API Endpoint:"
"
$edge_endpoint
"
}
}
...
@@ -150,33 +226,34 @@ _EDGEDNS_getZoneInfo() {
...
@@ -150,33 +226,34 @@ _EDGEDNS_getZoneInfo() {
_debug
"Getting Zoneinfo"
_debug
"Getting Zoneinfo"
zoneEnd
=
false
zoneEnd
=
false
curZone
=
$1
curZone
=
$1
while
[
-n
"
$
{
zoneEnd
}
"
]
;
do
while
[
-n
"
$zoneEnd
"
]
;
do
# we can strip the first part of the fulldomain, since its just the _acme-challenge string
# we can strip the first part of the fulldomain, since its just the _acme-challenge string
curZone
=
"
${
curZone
#*.
}
"
curZone
=
"
${
curZone
#*.
}
"
# suffix . needed for zone -> domain.tld.
# suffix . needed for zone -> domain.tld.
# create zone get url
# create zone get url
get_zone_url
=
$(
printf
"%s/%s"
"
$
{
edge_endpoint
}
"
"
$
{
curZone
}
"
)
get_zone_url
=
$(
printf
"%s/%s"
"
$edge_endpoint
"
"
$curZone
"
)
_debug3
"Zone Get: "
"
${
get_zone_url
}
"
_debug3
"Zone Get: "
"
${
get_zone_url
}
"
curResult
=
$(
_edgedns_rest GET
"
$get_zone_url
"
)
curResult
=
$(
_edgedns_rest GET
"
$get_zone_url
"
)
retVal
=
$?
retVal
=
$?
if
[
$retVal
-ne
0
]
;
then
if
[
"
$retVal
"
-ne
0
]
;
then
if
[
"
$curResult
"
!=
"404"
]
;
then
if
[
"
$curResult
"
=
"FATAL"
]
;
then
_err
"
$(
printf
"Managed zone validation failed. Error response: %s"
"
$retVal
"
)
"
_err
"
$(
printf
"Fatal error: acme API function call : %s"
"
$retVal
"
)
"
fi
if
[
"
$curResult
"
!=
"404"
]
;
then
err
"
$(
printf
"Managed zone validation failed. Error response: %s"
"
$retVal
"
)
"
return
1
return
1
fi
fi
fi
fi
if
_contains
"
$curResult
"
"
\"
zone
\"
:"
;
then
if
_contains
"
${
curResult
}
"
"
\"
zone
\"
:"
;
then
_debug2
"Zone data"
"
${
curResult
}
"
_debug2
"Zone data"
"
${
curResult
}
"
zone
=
$(
echo
-n
"
${
curResult
}
"
| _egrep_o
"
\"
zone
\"\\
s*:
\\
s*
\"
[^
\"
]*
\"
"
| _head_n 1 |
cut
-d
:
-f
2 |
tr
-d
"
\"
"
)
zone
=
$(
echo
"
${
curResult
}
"
| _egrep_o
"
\"
zone
\"\\
s*:
\\
s*
\"
[^
\"
]*
\"
"
| _head_n 1 |
cut
-d
:
-f
2 |
tr
-d
"
\"
"
)
_debug2
"Zone"
"
${
zone
}
"
_debug3
"Zone"
"
${
zone
}
"
zoneFound
=
""
zoneEnd
=
""
zoneEnd
=
""
return
0
return
0
fi
fi
if
[
"
${
curZone
#*.
}
"
!=
"
$curZone
"
]
;
then
if
[
"
${
curZone
#*.
}
"
!=
"
$curZone
"
]
;
then
_debug
2
$(
printf
"%s still contains a '.' - so we can check next higher level"
"
$curZone
"
)
_debug
3
"
$(
printf
"%s still contains a '.' - so we can check next higher level"
"
$curZone
"
)
"
else
else
zoneEnd
=
true
zoneEnd
=
true
_err
"Couldn't retrieve zone data."
_err
"Couldn't retrieve zone data."
...
@@ -205,52 +282,55 @@ _edgedns_rest() {
...
@@ -205,52 +282,55 @@ _edgedns_rest() {
tab
=
"
\t
"
tab
=
"
\t
"
# Set in acme.sh _post/_get
# Set in acme.sh _post/_get
#_edgedns_headers="${_edgedns_headers}${tab}User-Agent:ACME DNSAPI Edge DNS version ${ACME_EDGEDNS_VERSION}"
#_edgedns_headers="${_edgedns_headers}${tab}User-Agent:ACME DNSAPI Edge DNS version ${ACME_EDGEDNS_VERSION}"
_edgedns_headers
=
"
${
_edgedns_headers
}${
tab
}
Accept: application/json"
_edgedns_headers
=
"
${
_edgedns_headers
}${
tab
}
Accept: application/json
,*/*
"
if
[
"
$m
"
!=
"GET"
]
&&
[
"
$m
"
!=
"DELETE"
]
;
then
if
[
"
$m
"
!=
"GET"
]
&&
[
"
$m
"
!=
"DELETE"
]
;
then
_edgedns_content_type
=
"application/json
;charset=UTF-8
"
_edgedns_content_type
=
"application/json"
_
utf8_body_data
=
"
$(
echo
-n
"
$
_request_body"
| iconv
-t
utf-8
)
"
_
debug3
"_request_body"
"
$_request_body
"
_utf8
_body_len
=
"
$(
echo
-n
"
$_
utf8_body_data
"
|
awk
'{print length}'
)
"
_body_len
=
$(
echo
"
$_
request_body
"
|
tr
-d
"
\n\r
"
|
awk
'{print length}'
)
_edgedns_headers
=
"
${
_edgedns_headers
}${
tab
}
Content-Length:
${
_
utf8_
body_len
}
"
_edgedns_headers
=
"
${
_edgedns_headers
}${
tab
}
Content-Length:
${
_body_len
}
"
fi
fi
_made_auth_header
=
$(
_edgedns_make_auth_header
)
_edgedns_make_auth_header
_edgedns_headers
=
"
${
_edgedns_headers
}${
tab
}
Authorization:
${
_
made
_auth_header
}
"
_edgedns_headers
=
"
${
_edgedns_headers
}${
tab
}
Authorization:
${
_
signed
_auth_header
}
"
_secure_debug2
"Made Auth Header"
"
$
{
_made
_auth_header
}
"
_secure_debug2
"Made Auth Header"
"
$
_signed
_auth_header
"
hdr_indx
=
1
hdr_indx
=
1
work_header
=
"
${
_edgedns_headers
}${
tab
}
"
work_header
=
"
${
_edgedns_headers
}${
tab
}
"
_debug3
"work_header"
"
$
{
work_header
}
"
_debug3
"work_header"
"
$work_header
"
while
[
"
$
{
work_header
}
"
]
;
do
while
[
"
$work_header
"
]
;
do
entry
=
"
${
work_header
%%\\t*
}
"
;
work_header
=
"
${
work_header
#*\\t
}
"
entry
=
"
${
work_header
%%\\t*
}
"
;
work_header
=
"
${
work_header
#*\\t
}
"
export
"
$(
printf
"_H%s=%s"
"
$
{
hdr_indx
}
"
"
$
{
entry
}
"
)
"
export
"
$(
printf
"_H%s=%s"
"
$hdr_indx
"
"
$entry
"
)
"
_debug2
"Request Header "
"
$
{
entry
}
"
_debug2
"Request Header "
"
$entry
"
hdr_indx
=
$((
hdr_indx
+
1
))
hdr_indx
=
$((
hdr_indx
+
1
))
done
done
# clear headers from previous request to avoid getting wrong http code on timeouts
# clear headers from previous request to avoid getting wrong http code on timeouts
:>
"
$HTTP_HEADER
"
:
>
"
$HTTP_HEADER
"
_debug
"
$ep
"
_debug
2
"
$ep
"
if
[
"
$m
"
!=
"GET"
]
;
then
if
[
"
$m
"
!=
"GET"
]
;
then
_debug
"Method data"
"
$data
"
_debug
3
"Method data"
"
$data
"
# body url [needbase64] [POST|PUT|DELETE] [ContentType]
# body url [needbase64] [POST|PUT|DELETE] [ContentType]
response
=
"
$(
_post
"
$_
utf8_body_data
"
"
$ep
"
false
"
$m
"
)
"
response
=
$(
_post
"
$_
request_body
"
"
$ep
"
false
"
$m
"
"
$_edgedns_content_type
"
)
else
else
response
=
"
$(
_get
"
$ep
"
)
"
response
=
$(
_get
"
$ep
"
)
fi
fi
_ret
=
"
$?
"
_ret
=
"
$?
"
_debug
"response"
"
$response
"
if
[
"
$_ret
"
-ne
0
]
;
then
_err
"
$(
printf
"acme.sh API function call failed. Error: %s"
"
$_ret
"
)
"
echo
"FATAL"
return
"
$_ret
"
fi
_debug2
"response"
"
${
response
}
"
_code
=
"
$(
grep
"^HTTP"
"
$HTTP_HEADER
"
| _tail_n 1 |
cut
-d
" "
-f
2 |
tr
-d
"
\\
r
\\
n"
)
"
_code
=
"
$(
grep
"^HTTP"
"
$HTTP_HEADER
"
| _tail_n 1 |
cut
-d
" "
-f
2 |
tr
-d
"
\\
r
\\
n"
)
"
_debug2
"http response code"
"
$_code
"
_debug2
"http response code"
"
$_code
"
if
[
"
$_code
"
=
"200"
]
||
[
"
$_code
"
=
"201"
]
;
then
if
[
"
$_code
"
=
"200"
]
||
[
"
$_code
"
=
"201"
]
;
then
# All good
# All good
response
=
"
$(
echo
"
$response
"
| _normalizeJson
)
"
response
=
"
$(
echo
"
$
{
response
}
"
| _normalizeJson
)
"
echo
-n
"
$
{
response
}
"
echo
"
$response
"
return
0
return
0
fi
fi
if
[
"
$_code
"
=
"204"
]
;
then
if
[
"
$_code
"
=
"204"
]
;
then
# Success, no body
# Success, no body
echo
-n
"
"
echo
"
$_code
"
return
0
return
0
fi
fi
...
@@ -283,31 +363,30 @@ _edgedns_make_auth_header() {
...
@@ -283,31 +363,30 @@ _edgedns_make_auth_header() {
_edgedns_eg_timestamp
_edgedns_eg_timestamp
_edgedns_new_nonce
_edgedns_new_nonce
# "Unsigned authorization header: 'EG1-HMAC-SHA256 client_token=block;access_token=block;timestamp=20200806T14:16:33+0000;nonce=72cde72c-82d9-4721-9854-2ba057929d67;'"
# "Unsigned authorization header: 'EG1-HMAC-SHA256 client_token=block;access_token=block;timestamp=20200806T14:16:33+0000;nonce=72cde72c-82d9-4721-9854-2ba057929d67;'"
_auth_header
=
"
$(
printf
"EG1-HMAC-SHA256 client_token=%s;access_token=%s;timestamp=%s;nonce=%s;"
"
$
{
AKAMAI_CLIENT_TOKEN
}
"
"
$
{
AKAMAI_ACCESS_TOKEN
}
"
"
$
{
_eg_timestamp
}
"
"
$
{
_nonce
}
"
)
"
_auth_header
=
"
$(
printf
"EG1-HMAC-SHA256 client_token=%s;access_token=%s;timestamp=%s;nonce=%s;"
"
$AKAMAI_CLIENT_TOKEN
"
"
$AKAMAI_ACCESS_TOKEN
"
"
$_eg_timestamp
"
"
$_nonce
"
)
"
_secure_debug2
"Unsigned Auth Header: "
"
$_auth_header
"
_secure_debug2
"Unsigned Auth Header: "
"
$_auth_header
"
_sig
=
"
$(
_edgedns_sign_request
)
"
_edgedns_sign_request
_signed_auth_header
=
"
$(
printf
"%ssignature=%s"
"
$
{
_auth_header
}
"
"
$
{
_sig
}
"
)
"
_signed_auth_header
=
"
$(
printf
"%ssignature=%s"
"
$_auth_header
"
"
$_sig
ned_req
"
)
"
_secure_debug2
"Signed Auth Header: "
"
${
_signed_auth_header
}
"
_secure_debug2
"Signed Auth Header: "
"
${
_signed_auth_header
}
"
echo
-n
"
${
_signed_auth_header
}
"
}
}
_edgedns_sign_request
()
{
_edgedns_sign_request
()
{
_debug2
"Signing http request"
_debug2
"Signing http request"
_signed_data
=
$(
_edgedns_make_data_to_sign
"
$
{
_auth_header
}
"
)
_edgedns_make_data_to_sign
"
$_auth_header
"
_secure_debug2
"Returned signed data"
"
$_
signed_
data
"
_secure_debug2
"Returned signed data"
"
$_
m
data
"
_key
=
$(
_edgedns_make_signing_key
"
$
{
_eg_timestamp
}
"
)
_edgedns_make_signing_key
"
$_eg_timestamp
"
_signed_req
=
$(
_edgedns_base64_hmac_sha256
"
$_
signed_
data
"
"
$_key
"
)
_edgedns_base64_hmac_sha256
"
$_
m
data
"
"
$_
signing_
key
"
_s
ecure_debug2
"Signed Request"
"
${
_signed_req
}
"
_s
igned_req
=
"
$_hmac_out
"
echo
-n
"
$
{
_signed_req
}
"
_secure_debug2
"Signed Request"
"
$_signed_req
"
}
}
_edgedns_make_signing_key
()
{
_edgedns_make_signing_key
()
{
_debug2
"Creating sigining key"
_debug2
"Creating sigining key"
ts
=
$1
ts
=
$1
_signing_key
=
$(
_edgedns_base64_hmac_sha256
"
$ts
"
"
$
{
AKAMAI_CLIENT_SECRET
}
"
)
_edgedns_base64_hmac_sha256
"
$ts
"
"
$AKAMAI_CLIENT_SECRET
"
_s
ecure_debug2
"Signing Key"
"
${
_signing_key
}
"
_s
igning_key
=
"
$_hmac_out
"
echo
-n
"
$
{
_signing_key
}
"
_secure_debug2
"Signing Key"
"
$_signing_key
"
}
}
...
@@ -315,60 +394,50 @@ _edgedns_make_data_to_sign() {
...
@@ -315,60 +394,50 @@ _edgedns_make_data_to_sign() {
_debug2
"Processing data to sign"
_debug2
"Processing data to sign"
hdr
=
$1
hdr
=
$1
_secure_debug2
"hdr"
"
$hdr
"
_secure_debug2
"hdr"
"
$hdr
"
content_hash
=
$(
_edgedns_make_content_hash
)
_edgedns_make_content_hash
path
=
"
$(
echo
-n
"
$
{
_request_url_path
}
"
|sed
's/https\?:\/\///'
)
"
path
=
"
$(
echo
"
$_request_url_path
"
|
tr
-d
"
\n\r
"
|
sed
's/https\?:\/\///'
)
"
path
=
"
${
path
#*
$AKAMAI_HOST
}
"
path
=
"
${
path
#*
$AKAMAI_HOST
}
"
_debug
"hier path"
"
$
{
path
}
"
_debug
"hier path"
"
$path
"
# dont expose headers to sign so use MT string
# dont expose headers to sign so use MT string
data
=
"
$(
printf
"%s
\t
https
\t
%s
\t
%s
\t
%s
\t
%s
\t
%s"
"
${
_request_method
}
"
"
${
AKAMAI_HOST
}
"
"
${
path
}
"
""
"
${
content_hash
}
"
"
$hdr
"
)
"
_mdata
=
"
$(
printf
"%s
\t
https
\t
%s
\t
%s
\t
%s
\t
%s
\t
%s"
"
$_request_method
"
"
$AKAMAI_HOST
"
"
$path
"
""
"
$_hash
"
"
$hdr
"
)
"
_secure_debug2
"Data to Sign"
"
${
data
}
"
_secure_debug2
"Data to Sign"
"
$_mdata
"
echo
-n
"
${
data
}
"
}
}
_edgedns_make_content_hash
()
{
_edgedns_make_content_hash
()
{
_debug2
"Generating content hash"
_debug2
"Generating content hash"
prep_body
=
""
_hash
=
""
_hash
=
""
_debug2
"Request method"
"
${
_request_method
}
"
_debug2
"Request method"
"
${
_request_method
}
"
if
[
"
${
_request_method
}
"
!=
"POST"
]
||
[
-z
"
${
_request_body
}
"
]
;
then
if
[
"
$_request_method
"
!=
"POST"
]
||
[
-z
"
$_request_body
"
]
;
then
echo
-n
"
${
prep_body
}
"
return
0
return
0
fi
fi
prep_body
=
"
$(
echo
-n
"
${
_request_body
}
"
)
"
_debug2
"Req body"
"
$_request_body
"
_debug2
"Req body"
"
${
prep_body
}
"
_edgedns_base64_sha256
"
$_request_body
"
_hash
=
$(
_edgedns_base64_sha256
"
${
prep_body
}
"
)
_hash
=
"
$_sha256_out
"
_debug2
"Content hash"
"
${
_hash
}
"
_debug2
"Content hash"
"
$_hash
"
echo
-n
"
${
_hash
}
"
}
}
_edgedns_base64_hmac_sha256
()
{
_edgedns_base64_hmac_sha256
()
{
_debug2
"Generating hmac"
_debug2
"Generating hmac"
data
=
$1
data
=
$1
key
=
$2
key
=
$2
encoded_data
=
"
$(
echo
-n
"
${
data
}
"
| iconv
-t
utf-8
)
"
encoded_data
=
"
$(
echo
"
$data
"
| iconv
-t
utf-8
)
"
encoded_key
=
"
$(
echo
-n
"
${
key
}
"
| iconv
-t
utf-8
)
"
encoded_key
=
"
$(
echo
"
$key
"
| iconv
-t
utf-8
)
"
_secure_debug2
"encoded data"
"
${
encoded_data
}
"
_secure_debug2
"encoded data"
"
$encoded_data
"
_secure_debug2
"encoded key"
"
${
encoded_key
}
"
_secure_debug2
"encoded key"
"
$encoded_key
"
#key_hex="$(_durl_replace_base64 "$key" | _dbase64 | _hex_dump | tr -d ' ')"
#data_sig="$(printf "%s" "$encoded_data" | _hmac sha256 "${key_hex}" | _base64 | _url_replace)"
data_sig
=
"
$(
echo
"
$encoded_data
"
|
tr
-d
"
\n\r
"
|
${
ACME_OPENSSL_BIN
:-
openssl
}
dgst
-sha256
-hmac
"
$encoded_key
"
-binary
| _base64
)
"
_secure_debug2
"data_sig:"
"
$data_sig
"
data_sig
=
"
$(
echo
-n
"
$encoded_data
"
|
${
ACME_OPENSSL_BIN
:-
openssl
}
dgst
-sha256
-hmac
$encoded_key
-binary
| _base64
)
"
_hmac_out
=
"
$(
echo
"
$data_sig
"
|
tr
-d
"
\n\r
"
| iconv
-f
utf-8
)
"
_secure_debug2
"data_sig:"
"
${
data_sig
}
"
_secure_debug2
"hmac"
"
$_hmac_out
"
out
=
"
$(
echo
-n
"
${
data_sig
}
"
| iconv
-f
utf-8
)
"
_secure_debug2
"hmac"
"
${
out
}
"
echo
-n
"
${
out
}
"
}
}
_edgedns_base64_sha256
()
{
_edgedns_base64_sha256
()
{
_debug2
"Creating sha256 digest"
_debug2
"Creating sha256 digest"
trg
=
$1
trg
=
$1
utf8_str
=
"
$(
echo
-n
"
${
trg
}
"
| iconv
-t
utf-8
)
"
_secure_debug2
"digest data"
"
$trg
"
_secure_debug2
"digest data"
"
$trg
"
_secure_debug2
"encoded digest data"
"
${
utf8_str
}
"
digest
=
"
$(
echo
"
$trg
"
|
tr
-d
"
\n\r
"
|
${
ACME_OPENSSL_BIN
:-
openssl
}
dgst
-sha256
-binary
| _base64
)
"
digest
=
"
$(
echo
-n
"
${
trg
}
"
|
${
ACME_OPENSSL_BIN
:-
openssl
}
dgst
-sha256
-binary
| _base64
)
"
_sha256_out
=
"
$(
echo
"
$digest
"
|
tr
-d
"
\n\r
"
| iconv
-f
utf-8
)
"
out
=
"
$(
echo
-n
"
${
digest
}
"
| iconv
-f
utf-8
)
"
_secure_debug2
"digest decode"
"
$_sha256_out
"
_secure_debug2
"digest decode"
"
${
out
}
"
echo
-n
"
${
out
}
"
}
}
#_edgedns_parse_edgerc() {
#_edgedns_parse_edgerc() {
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment