diff --git a/deps/oblib/src/lib/restore/cos/ob_cos_wrapper.cpp b/deps/oblib/src/lib/restore/cos/ob_cos_wrapper.cpp
index 96556a965f..15e09f7c6d 100644
--- a/deps/oblib/src/lib/restore/cos/ob_cos_wrapper.cpp
+++ b/deps/oblib/src/lib/restore/cos/ob_cos_wrapper.cpp
@@ -205,7 +205,7 @@ int ObCosEnv::init()
   if (is_inited_) {
     ret = OB_INIT_TWICE;
     cos_warn_log("[COS]cannot init cos env more than once, ret=%d\n", ret);
-  } else if(COSE_OK != (cos_ret = cos_http_io_initialize(NULL, 0))) {
+  } else if (COSE_OK != (cos_ret = cos_http_io_initialize(NULL, 0))) {
     ret = OB_COS_ERROR;
     cos_warn_log("[COS]fail to init cos env, cos_ret=%d, ret=%d\n", cos_ret, ret);
   } else {
@@ -527,7 +527,7 @@ int ObCosWrapper::head_object_meta(
       ret = OB_ALLOCATE_MEMORY_FAILED;
       cos_warn_log("[COS]fail to allocate header memory, ret=%d\n", ret);
     } else if (NULL == (cos_ret = cos_head_object(ctx->options, &bucket, &object, headers, &resp_headers))
-        || !cos_status_is_ok(cos_ret)) {
+               || !cos_status_is_ok(cos_ret)) {
       if (NULL != cos_ret && COS_OBJECT_NOT_EXIST == cos_ret->code) {
         is_exist = false;
       } else {
@@ -736,7 +736,10 @@ int ObCosWrapper::del_objects_in_dir(
           cos_list_for_each_entry(cos_list_object_content_t, content, &params->object_list, node) {
             // Check if the prefix of returned object key match the dir_name
             size_t dir_name_str_len = strlen(dir_name.data_);
-            if (0 != memcmp(content->key.data, dir_name.data_, dir_name_str_len)) {
+            if (NULL == content->key.data) {
+              ret = OB_COS_ERROR;
+              cos_warn_log("[COS]returned object key data is null, dir=%s, ret=%d\n", dir_name.data_, ret);
+            } else if (0 != memcmp(content->key.data, dir_name.data_, dir_name_str_len)) {
               ret = OB_COS_ERROR;
               cos_warn_log("[COS]returned object prefix not match, dir=%s, object=%s, ret=%d\n", dir_name.data_, content->key.data, ret);
             } else if (NULL == (to_delete_object = cos_create_cos_object_key(ctx->mem_pool))) {
@@ -772,7 +775,13 @@ int ObCosWrapper::del_objects_in_dir(
           // Delete next batch of objects.
           char *next_marker_str = NULL;
           if (OB_SUCCESS == ret && COS_TRUE == params->truncated) {
-            if (NULL == (next_marker_str = apr_psprintf(ctx->mem_pool, "%.*s", params->next_marker.len, params->next_marker.data))) {
+            if (nullptr == params->next_marker.data || params->next_marker.len == 0) {
+              ret = OB_COS_ERROR;
+              cos_warn_log("[COS]returned next marker is invalid, data=%s, len=%d, ret=%d\n",
+                  params->next_marker.data, params->next_marker.len, ret);
+            } else if (NULL == (next_marker_str = apr_psprintf(ctx->mem_pool, "%.*s",
+                                                               params->next_marker.len,
+                                                               params->next_marker.data))) {
               ret = OB_COS_ERROR;
               cos_warn_log("[COS]get next marker is null, ret=%d\n", ret);
             } else {
@@ -937,6 +946,11 @@ int ObCosWrapper::pread(
             cos_warn_log("[COS]unexpected error, too much data returned, ret=%d, range_size=%s, buf_pos=%ld, size=%ld, req_id=%s.\n", ret, range_size, buf_pos, size, cos_ret->req_id);
             log_status(cos_ret, ret);
             break;
+          } else if (NULL == content->pos) {
+            ret = OB_COS_ERROR;
+            cos_warn_log("[COS]unexpected error, data pos is null, ret=%d, range_size=%s, buf_pos=%ld, size=%ld, req_id=%s.\n", ret, range_size, buf_pos, size, cos_ret->req_id);
+            log_status(cos_ret, ret);
+            break;
           } else {
             // copy to buf
             memcpy(buf + buf_pos, content->pos, (size_t)needed_size);
@@ -1011,17 +1025,20 @@ int ObCosWrapper::is_object_tagging(
         char key_str[MAX_TAGGING_STR_LEN];
         char value_str[MAX_TAGGING_STR_LEN];
 
-        int key_n = snprintf(key_str, MAX_TAGGING_STR_LEN, "%.*s", tag->key.len, tag->key.data);
-        int val_n = snprintf(value_str, MAX_TAGGING_STR_LEN, "%.*s", tag->key.len, tag->value.data);
-        if (0 >= key_n || MAX_TAGGING_STR_LEN <= key_n) {
-          ret = OB_SIZE_OVERFLOW;
-          cos_warn_log("[COS]fail to format tag, key_n=%d, ret=%d\n", key_n, ret);
-        } else if (0 >= val_n || MAX_TAGGING_STR_LEN <= val_n) {
-          ret = OB_SIZE_OVERFLOW;
-          cos_warn_log("[COS]fail to format tag, val_n=%d, ret=%d\n", val_n, ret);
-        } else if (0 == strcmp("delete_mode", key_str) && 0 == strcmp("tagging", value_str)) {
-          is_tagging = true;
+        if ((NULL != tag->key.data) && (NULL != tag->value.data)) {
+          int key_n = snprintf(key_str, MAX_TAGGING_STR_LEN, "%.*s", tag->key.len, tag->key.data);
+          int val_n = snprintf(value_str, MAX_TAGGING_STR_LEN, "%.*s", tag->key.len, tag->value.data);
+          if (0 >= key_n || MAX_TAGGING_STR_LEN <= key_n) {
+            ret = OB_SIZE_OVERFLOW;
+            cos_warn_log("[COS]fail to format tag, key_n=%d, ret=%d\n", key_n, ret);
+          } else if (0 >= val_n || MAX_TAGGING_STR_LEN <= val_n) {
+            ret = OB_SIZE_OVERFLOW;
+            cos_warn_log("[COS]fail to format tag, val_n=%d, ret=%d\n", val_n, ret);
+          } else if (0 == strcmp("delete_mode", key_str) && 0 == strcmp("tagging", value_str)) {
+            is_tagging = true;
+          }
         }
+
         if (OB_SUCCESS != ret) {
           break;
         }
@@ -1161,7 +1178,10 @@ int ObCosWrapper::list_objects(
         cos_list_for_each_entry(cos_list_object_content_t, content, &params->object_list, node) {
           // check if the prefix of returned object key match the full_dir_path
           size_t full_dir_path_len = strlen(full_dir_path.data_);
-          if (false == full_dir_path.is_prefix_of(content->key.data, content->key.len)) {
+          if (nullptr == content->key.data || 0 == content->key.len) {
+            ret = OB_COS_ERROR;
+            cos_warn_log("[COS]returned object key is invalid, dir=%s, requestid=%s, ret=%d\n", full_dir_path.data_, request_id, ret);
+          } else if (false == full_dir_path.is_prefix_of(content->key.data, content->key.len)) {
             ret = OB_COS_ERROR;
             cos_warn_log("[COS]returned object prefix not match, dir=%s, object=%s, requestid=%s, ret=%d\n",
                 full_dir_path.data_, content->key.data, request_id, ret);
@@ -1185,9 +1205,13 @@ int ObCosWrapper::list_objects(
         }  // end cos_list_for_each_entry
 
         if (OB_SUCCESS == ret && COS_TRUE == params->truncated) {
-          if (NULL == (cos_list_args.next_marker_ = apr_psprintf(ctx->mem_pool, "%.*s",
-                                                                 params->next_marker.len,
-                                                                 params->next_marker.data))) {
+          if (nullptr == params->next_marker.data || params->next_marker.len == 0) {
+            ret = OB_COS_ERROR;
+            cos_warn_log("[COS]returned next marker is invalid, data=%s, len=%d, ret=%d\n",
+                params->next_marker.data, params->next_marker.len, ret);
+          } else if (nullptr == (cos_list_args.next_marker_ = apr_psprintf(ctx->mem_pool, "%.*s",
+                                                                           params->next_marker.len,
+                                                                           params->next_marker.data))) {
             ret = OB_COS_ERROR;
             cos_warn_log("[COS]get next marker is null, ret=%d\n", ret);
           }
@@ -1235,7 +1259,11 @@ int ObCosWrapper::list_part_objects(
       cos_list_for_each_entry(cos_list_object_content_t, content, &params->object_list, node) {
         // check if the prefix of returned object key match the full_dir_path
         size_t full_dir_path_len = strlen(full_dir_path.data_);
-        if (false == full_dir_path.is_prefix_of(content->key.data, content->key.len)) {
+        if (nullptr == content->key.data || content->key.len <= 0) {
+            ret = OB_COS_ERROR;
+            cos_warn_log("[COS]returned object key is invalid, dir=%s, requestid=%s, ret=%d\n",
+                full_dir_path.data_, request_id, ret);
+        } else if (false == full_dir_path.is_prefix_of(content->key.data, content->key.len)) {
           ret = OB_COS_ERROR;
           cos_warn_log("[COS]returned object prefix not match, dir=%s, object=%s, requestid=%s, ret=%d\n",
               full_dir_path.data_, content->key.data, request_id, ret);
@@ -1326,7 +1354,10 @@ int ObCosWrapper::list_directories(
           const int64_t listed_dir_full_path_len = common_prefix->prefix.len;
           // check if the prefix of returned object key match the dir_name
           const size_t dir_name_str_len = strlen(dir_name.data_);
-          if (false == dir_name.is_prefix_of(listed_dir_full_path, listed_dir_full_path_len)) {
+          if (nullptr == listed_dir_full_path || listed_dir_full_path_len <= 0) {
+            ret = OB_COS_ERROR;
+            cos_warn_log("[COS]returned dirs is invalid, dir=%s, requestid=%s, ret=%d\n", dir_name.data_, request_id, ret);
+          } else if (false == dir_name.is_prefix_of(listed_dir_full_path, listed_dir_full_path_len)) {
             ret = OB_COS_ERROR;
             cos_warn_log("[COS]returned object prefix not match, dir=%s, object=%s, requestid=%s, ret=%d, obj_path_len=%d, dir_name_len=%d\n",
                 dir_name.data_, listed_dir_full_path, request_id, ret, listed_dir_full_path_len, dir_name.size_);
@@ -1353,9 +1384,13 @@ int ObCosWrapper::list_directories(
         } // end cos_list_for_each_entry
 
         if (OB_SUCCESS == ret && COS_TRUE == params->truncated) {
-          if (NULL == (cos_list_args.next_marker_ = apr_psprintf(ctx->mem_pool, "%.*s",
-                                                                 params->next_marker.len,
-                                                                 params->next_marker.data))) {
+          if (nullptr == params->next_marker.data || params->next_marker.len == 0) {
+            ret = OB_COS_ERROR;
+            cos_warn_log("[COS]returned next marker is invalid, data=%s, len=%d, ret=%d\n",
+                params->next_marker.data, params->next_marker.len, ret);
+          } else if (nullptr == (cos_list_args.next_marker_ = apr_psprintf(ctx->mem_pool, "%.*s",
+                                                                           params->next_marker.len,
+                                                                           params->next_marker.data))) {
             ret = OB_COS_ERROR;
             cos_warn_log("[COS]get next marker is null, ret=%d\n", ret);
           }
@@ -1555,6 +1590,11 @@ int ObCosWrapper::complete_multipart_upload(
             if (NULL == complete_part) {
               ret = OB_ALLOCATE_MEMORY_FAILED;
               cos_warn_log("[COS]fail to create complete part content, ret=%d\n", ret);
+            } else if (nullptr == part_content->part_number.data
+                      || nullptr == part_content->etag.data) {
+              ret = OB_COS_ERROR;
+              cos_warn_log("[COS]invalid part_number or etag, part_number=%s, etag=%s ret=%d\n",
+                  part_content->part_number.data, part_content->etag.data, ret);
             } else {
               cos_str_set(&complete_part->part_number, part_content->part_number.data);
               cos_str_set(&complete_part->etag, part_content->etag.data);
@@ -1564,7 +1604,12 @@ int ObCosWrapper::complete_multipart_upload(
 
           if (OB_SUCCESS == ret && COS_TRUE == params->truncated) {
             const char *next_part_number_marker = NULL;
-            if (NULL == (next_part_number_marker =
+            if (nullptr == params->next_part_number_marker.data
+                || params->next_part_number_marker.len == 0) {
+              ret = OB_COS_ERROR;
+              cos_warn_log("[COS]returned next part number marker is invalid, data=%s, len=%d, ret=%d\n",
+                  params->next_part_number_marker.data, params->next_part_number_marker.len, ret);
+            } else if (nullptr == (next_part_number_marker =
                 apr_psprintf(ctx->mem_pool, "%.*s",
                              params->next_part_number_marker.len,
                              params->next_part_number_marker.data))) {
@@ -1687,9 +1732,16 @@ int ObCosWrapper::del_unmerged_parts(
         cos_warn_log("[COS]fail to list multipart uploads, ret=%d\n", ret);
         log_status(cos_ret, ret);
       } else {
+        char *request_id = (char*)apr_table_get(resp_headers, "x-cos-request-id");
         cos_list_for_each_entry(cos_list_multipart_upload_content_t, content, &params->upload_list, node) {
-          if (NULL == (cos_ret = cos_abort_multipart_upload(ctx->options, &bucket, &(content->key),
-                                                            &(content->upload_id), &resp_headers))
+          if (nullptr == content->key.data || nullptr == content->upload_id.data) {
+            ret = OB_COS_ERROR;
+            cos_warn_log("[COS]returned key or upload id is invalid, dir=%s, requestid=%s, ret=%d, key=%s, upload id=%s\n",
+                object_name.data_, request_id, ret, content->key.data, content->upload_id.data);
+          } else if (nullptr == (cos_ret = cos_abort_multipart_upload(ctx->options, &bucket,
+                                                                      &(content->key),
+                                                                      &(content->upload_id),
+                                                                      &resp_headers))
               || !cos_status_is_ok(cos_ret)) {
             convert_io_error(cos_ret, ret);
             cos_warn_log("[COS]fail to abort multipart upload, ret=%d, bucket=%s, object=%s, upload_id=%s\n",
@@ -1704,9 +1756,15 @@ int ObCosWrapper::del_unmerged_parts(
       }
 
       if (OB_SUCCESS == ret && COS_TRUE == params->truncated) {
-        if (NULL == (next_key_marker = apr_psprintf(ctx->mem_pool, "%.*s",
-                                                    params->next_key_marker.len,
-                                                    params->next_key_marker.data))) {
+        if (nullptr == params->next_key_marker.data || nullptr == params->next_upload_id_marker.data
+            || params->next_key_marker.len == 0 || params->next_upload_id_marker.len == 0) {
+          ret = OB_COS_ERROR;
+          cos_warn_log("[COS]returned key marker or upload id is invalid, key data=%s, key len=%d, upload id data=%s, upload id len=%d, ret=%d\n",
+              params->next_key_marker.data, params->next_key_marker.len,
+              params->next_upload_id_marker.data, params->next_upload_id_marker.len, ret);
+        } else if (nullptr == (next_key_marker = apr_psprintf(ctx->mem_pool, "%.*s",
+                                                              params->next_key_marker.len,
+                                                              params->next_key_marker.data))) {
           ret = OB_COS_ERROR;
           cos_warn_log("[COS]get next key marker is null, ret=%d\n", ret);
         } else if (NULL == (next_upload_id_marker = apr_psprintf(ctx->mem_pool, "%.*s",
diff --git a/deps/oblib/src/lib/restore/ob_storage_file.cpp b/deps/oblib/src/lib/restore/ob_storage_file.cpp
index 2e10ad6e68..0f57976255 100644
--- a/deps/oblib/src/lib/restore/ob_storage_file.cpp
+++ b/deps/oblib/src/lib/restore/ob_storage_file.cpp
@@ -45,9 +45,9 @@ int get_file_path(const common::ObString &uri, char *buf, const int64_t buf_size
   int ret = OB_SUCCESS;
   int64_t offset = strlen(OB_FILE_PREFIX);
 
-  if (uri.empty()) {
+  if (uri.empty() || OB_ISNULL(buf)) {
     ret = OB_INVALID_ARGUMENT;
-    STORAGE_LOG(WARN, "invalid args", K(ret), K(uri));
+    STORAGE_LOG(WARN, "invalid args", K(ret), K(uri), KP(buf));
   } else if (!uri.prefix_match(OB_FILE_PREFIX)) {
     ret = OB_INVALID_ARGUMENT;
     STORAGE_LOG(WARN, "invalid uri", K(ret), K(uri));
diff --git a/deps/oblib/src/lib/restore/ob_storage_oss_base.cpp b/deps/oblib/src/lib/restore/ob_storage_oss_base.cpp
index 51c3f5cd0e..63e8650708 100644
--- a/deps/oblib/src/lib/restore/ob_storage_oss_base.cpp
+++ b/deps/oblib/src/lib/restore/ob_storage_oss_base.cpp
@@ -306,7 +306,7 @@ int ObOssEnvIniter::global_init()
   if (is_global_inited_) {
     ret = OB_INIT_TWICE;
     OB_LOG(WARN, "cannot init twice", K(ret));
-  } else if(AOSE_OK != (aos_ret = aos_http_io_initialize(NULL, 0))) {
+  } else if (AOSE_OK != (aos_ret = aos_http_io_initialize(NULL, 0))) {
     ret = OB_OSS_ERROR;
     OB_LOG(WARN, "fail to init aos", K(aos_ret));
   } else {
@@ -362,8 +362,8 @@ ObStorageOssBase::~ObStorageOssBase()
 void ObStorageOssBase::reset()
 {
   memset(oss_endpoint_, 0, MAX_OSS_ENDPOINT_LENGTH);
-  if(is_inited_) {
-    if(NULL != aos_pool_) {
+  if (is_inited_) {
+    if (NULL != aos_pool_) {
       aos_pool_destroy(aos_pool_);
       aos_pool_ = NULL;
     }
@@ -378,7 +378,7 @@ int ObStorageOssBase::init_with_storage_info(common::ObObjectStorageInfo *storag
   int ret = OB_SUCCESS;
   char info_str[common::OB_MAX_BACKUP_STORAGE_INFO_LENGTH] = { 0 };
 
-  if(OB_UNLIKELY(is_inited_)) {
+  if (OB_UNLIKELY(is_inited_)) {
     ret = OB_INIT_TWICE;
     OB_LOG(WARN, "oss client init twice", K(ret));
   } else if (OB_ISNULL(storage_info)) {
@@ -431,7 +431,7 @@ int ObOssAccount::parse_oss_arg(const common::ObString &storage_info)
 {
   int ret = OB_SUCCESS;
 
-  if(is_inited_) {
+  if (is_inited_) {
     ret = OB_INIT_TWICE;
     OB_LOG(WARN, "oss client init twice", K(ret));
   } else if (OB_ISNULL(storage_info.ptr()) || storage_info.length() >= OB_MAX_URI_LENGTH) {
@@ -552,7 +552,7 @@ int ObStorageOssBase::reinit_oss_option()
   if (!is_inited()) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "please init first", K(ret));
-  } else if(OB_FAIL(init_oss_endpoint())) {
+  } else if (OB_FAIL(init_oss_endpoint())) {
     OB_LOG(WARN, "fail to init oss endpoint", K(ret));
   } else {
     //reset oss_option endpoint
@@ -597,9 +597,12 @@ int ObStorageOssBase::get_oss_file_meta(const ObString &bucket_ob_string,
   remote_md5 = NULL;
   file_length = -1;
 
-  if(!is_inited()) {
+  if (!is_inited()) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "oss client not inited", K(ret));
+  } else if (OB_ISNULL(bucket_ob_string.ptr()) || OB_ISNULL(object_ob_string.ptr())) {
+    ret = OB_INVALID_ARGUMENT;
+    OB_LOG(WARN, "invalid argument", K(ret), K(bucket_ob_string), K(object_ob_string));
   } else {
     aos_string_t bucket;
     aos_string_t object;
@@ -719,7 +722,7 @@ int ObStorageOssMultiPartWriter::open(const ObString &uri, common::ObObjectStora
     } else if (OB_ISNULL(headers = aos_table_make(aos_pool_, AOS_TABLE_INIT_SIZE))) {
       ret = OB_OSS_ERROR;
       OB_LOG(WARN, "fail to make apr table", K(ret));
-    } else if(NULL == (aos_ret = oss_init_multipart_upload(oss_option_, &bucket, &object, &upload_id_,
+    } else if (NULL == (aos_ret = oss_init_multipart_upload(oss_option_, &bucket, &object, &upload_id_,
                                                            headers, &resp_headers))
               || !aos_status_is_ok(aos_ret)) {
       ret = OB_OSS_ERROR;
@@ -740,13 +743,13 @@ int ObStorageOssMultiPartWriter::write(const char * buf,const int64_t size)
   ObExternalIOCounterGuard io_guard;
   int64_t fill_size = 0;
   int64_t buf_pos = 0;
-  if(!is_inited()) {
+  if (!is_inited()) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "oss client not inited", K(ret));
-  } else if(NULL == buf || size < 0) {
+  } else if (NULL == buf || size < 0) {
     ret = OB_INVALID_ARGUMENT;
     OB_LOG(WARN, "buf is NULL or size is invalid", KP(buf), K(size), K(ret));
-  } else if(!is_opened_) {
+  } else if (!is_opened_) {
     ret = OB_OSS_ERROR;
     OB_LOG(WARN, "oss writer cannot write before it is opened", K(ret));
   }
@@ -770,7 +773,7 @@ int ObStorageOssMultiPartWriter::write(const char * buf,const int64_t size)
     }
   }
 
-  if(OB_SUCCESS == ret) {
+  if (OB_SUCCESS == ret) {
     file_length_ += size;
   }
   return ret;
@@ -822,15 +825,15 @@ int ObStorageOssMultiPartWriter::write_single_part()
   if(partnum_ > OSS_MAX_PART_NUM) {
     ret = OB_OUT_OF_ELEMENT;
     OB_LOG(WARN, "Out of oss element ", K(partnum_), K(OSS_MAX_PART_NUM), K(ret));
-  } else if(!is_inited()) {
+  } else if (!is_inited()) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "please init first", K(ret));
-  } else if(!is_opened_) {
+  } else if (!is_opened_) {
     ret = OB_OSS_ERROR;
     OB_LOG(WARN, "write oss should open first", K(ret));
   }
 
-  if(OB_SUCCESS == ret) {
+  if (OB_SUCCESS == ret) {
     //upload data
     aos_string_t bucket;
     aos_string_t object;
@@ -938,6 +941,12 @@ int ObStorageOssMultiPartWriter::close()
               ret = OB_OSS_ERROR;
               OB_LOG(WARN, "fail to create complete part content", K_(bucket), K_(object), K(ret));
               break;
+            } else if (OB_ISNULL(part_content->part_number.data)
+                      || OB_ISNULL(part_content->etag.data)) {
+              ret = OB_OSS_ERROR;
+              OB_LOG(WARN, "invalid part_number or etag",
+                  K(ret), KP(part_content->part_number.data), KP(part_content->etag.data));
+              break;
             } else {
               aos_str_set(&complete_part_content->part_number, part_content->part_number.data);
               aos_str_set(&complete_part_content->etag, part_content->etag.data);
@@ -947,7 +956,12 @@ int ObStorageOssMultiPartWriter::close()
 
           if (OB_SUCC(ret) && AOS_TRUE == params->truncated) {
             const char *next_part_number_marker = NULL;
-            if (OB_ISNULL(next_part_number_marker =
+            if (OB_ISNULL(params->next_part_number_marker.data)
+                || OB_UNLIKELY(params->next_part_number_marker.len <= 0)) {
+              ret = OB_OSS_ERROR;
+              OB_LOG(WARN, "next_part_number_marker is invalid", K(ret),
+                  K(params->next_part_number_marker.data), K(params->next_part_number_marker.len));
+            } else if (OB_ISNULL(next_part_number_marker =
                 apr_psprintf(aos_pool_, "%.*s",
                              params->next_part_number_marker.len,
                              params->next_part_number_marker.data))) {
@@ -1037,10 +1051,10 @@ int ObStorageOssReader::open(const ObString &uri,
   char *remote_md5 = NULL;
   int64_t file_length = -1;
 
-  if(uri.empty()) {
+  if (uri.empty()) {
     ret = OB_INVALID_ARGUMENT;
     OB_LOG(WARN, "uri is empty", K(ret));
-  } else if(is_opened_) {
+  } else if (is_opened_) {
     ret = OB_OSS_ERROR;
     OB_LOG(WARN, "already open, cannot open again", K(ret));
   } else if (OB_FAIL(init_with_storage_info(storage_info))) {
@@ -1178,6 +1192,9 @@ int ObStorageOssReader::pread(
                 ret = OB_SIZE_OVERFLOW;
                 OB_LOG(WARN, "the size is too long", K(buf_pos), K(size), K(get_data_size), K(ret));
                 break;
+              } else if (OB_ISNULL(content->pos)) {
+                ret = OB_OSS_ERROR;
+                OB_LOG(WARN, "unexpected error, the data pos is null", K(size), K(ret));
               } else {
                 memcpy(buf + buf_pos, content->pos, (size_t)needed_size);
                 buf_pos += needed_size;
@@ -1198,7 +1215,7 @@ int ObStorageOssReader::pread(
       }
     }//if(file_length_ - file_offset_ > 0)
   }
-  if(NULL != aos_pool) {
+  if (NULL != aos_pool) {
     aos_pool_destroy(aos_pool);
   }
 
@@ -1366,13 +1383,16 @@ int ObStorageOssUtil::is_tagging(
       aos_list_for_each_entry(oss_tag_content_t, b, &tag_list, node) {
         char key_str[OB_MAX_TAGGING_STR_LENGTH];
         char value_str[OB_MAX_TAGGING_STR_LENGTH];
-        if (OB_FAIL(databuff_printf(key_str, OB_MAX_TAGGING_STR_LENGTH , "%.*s",b->key.len, b->key.data))) {
-          OB_LOG(WARN, "failed to databuff printf key str", K(ret));
-        } else if (OB_FAIL(databuff_printf(value_str, OB_MAX_TAGGING_STR_LENGTH, "%.*s", b->key.len, b->value.data))) {
-          OB_LOG(WARN, "failed to databuff printf value str", K(ret));
-        } else if (0 == strcmp("delete_mode", key_str) && 0 == strcmp("tagging", value_str)) {
-          is_tagging = true;
+        if (OB_NOT_NULL(b->key.data) && OB_NOT_NULL(b->value.data)) {
+          if (OB_FAIL(databuff_printf(key_str, OB_MAX_TAGGING_STR_LENGTH , "%.*s",b->key.len, b->key.data))) {
+            OB_LOG(WARN, "failed to databuff printf key str", K(ret));
+          } else if (OB_FAIL(databuff_printf(value_str, OB_MAX_TAGGING_STR_LENGTH, "%.*s", b->key.len, b->value.data))) {
+            OB_LOG(WARN, "failed to databuff printf value str", K(ret));
+          } else if (0 == strcmp("delete_mode", key_str) && 0 == strcmp("tagging", value_str)) {
+            is_tagging = true;
+          }
         }
+
         if (OB_FAIL(ret)) {
           break;
         }
@@ -1620,9 +1640,13 @@ int ObStorageOssUtil::list_files(
         } // end aos_list_for_each_entry
       }
       if (OB_SUCC(ret) && AOS_TRUE == params->truncated) {
-        if (NULL == (next_marker = apr_psprintf(oss_base.aos_pool_, "%.*s",
-                                                params->next_marker.len,
-                                                params->next_marker.data))) {
+        if (OB_ISNULL(params->next_marker.data) || OB_UNLIKELY(params->next_marker.len <= 0)) {
+          ret = OB_OSS_ERROR;
+          OB_LOG(WARN, "next_marker is invalid", K(ret),
+              K(params->next_marker.data), K(params->next_marker.len));
+        } else if (nullptr == (next_marker = apr_psprintf(oss_base.aos_pool_, "%.*s",
+                                                          params->next_marker.len,
+                                                          params->next_marker.data))) {
           ret = OB_OSS_ERROR;
           OB_LOG(WARN, "next marker is NULL", K(ret), KP(next_marker), K(params->next_marker.data));
         }
@@ -1812,9 +1836,13 @@ int ObStorageOssUtil::list_directories(
         } // end aos_list_for_each_entry
       }
       if (OB_SUCC(ret) && AOS_TRUE == params->truncated) {
-        if (NULL == (next_marker = apr_psprintf(oss_base.aos_pool_, "%.*s",
-                                                params->next_marker.len,
-                                                params->next_marker.data))) {
+        if (OB_ISNULL(params->next_marker.data) || OB_UNLIKELY(params->next_marker.len <= 0)) {
+          ret = OB_OSS_ERROR;
+          OB_LOG(WARN, "next_marker is invalid", K(ret),
+              K(params->next_marker.data), K(params->next_marker.len));
+        } else if (nullptr == (next_marker = apr_psprintf(oss_base.aos_pool_, "%.*s",
+                                                          params->next_marker.len,
+                                                          params->next_marker.data))) {
           ret = OB_OSS_ERROR;
           OB_LOG(WARN, "next marker is NULL", K(ret), KP(next_marker), K(params->next_marker.data));
         }
@@ -1872,8 +1900,14 @@ int ObStorageOssUtil::del_unmerged_parts(const ObString &uri)
         oss_base.print_oss_info(resp_headers, aos_ret, ret);
       } else {
         aos_list_for_each_entry(oss_list_multipart_upload_content_t, content, &params->upload_list, node) {
-          if (OB_ISNULL(aos_ret = oss_abort_multipart_upload(oss_base.oss_option_, &bucket, &(content->key),
-                                                             &(content->upload_id), &resp_headers))
+          if (OB_ISNULL(content->key.data) || OB_ISNULL(content->upload_id.data)) {
+            ret = OB_OSS_ERROR;
+            OB_LOG(WARN, "returned key or upload id invalid",
+                K(ret), K(content->key.data), K(content->upload_id.data));
+          } else if (OB_ISNULL(aos_ret = oss_abort_multipart_upload(oss_base.oss_option_, &bucket,
+                                                                    &(content->key),
+                                                                    &(content->upload_id),
+                                                                    &resp_headers))
               || !aos_status_is_ok(aos_ret)) {
             convert_io_error(aos_ret, ret);
             OB_LOG(WARN, "fail to abort oss multipart upload",
@@ -1888,7 +1922,13 @@ int ObStorageOssUtil::del_unmerged_parts(const ObString &uri)
       }
 
       if (OB_SUCC(ret) && AOS_TRUE == params->truncated) {
-        if (OB_ISNULL(next_key_marker =
+        if (OB_ISNULL(params->next_key_marker.data) || OB_ISNULL(params->next_upload_id_marker.data)
+            || OB_UNLIKELY(params->next_key_marker.len <= 0 || params->next_upload_id_marker.len <= 0)) {
+          ret = OB_OSS_ERROR;
+          OB_LOG(WARN, "next_key_marker or next_upload_id_marker is invalid", K(ret),
+              K(params->next_key_marker.data), K(params->next_key_marker.len),
+              K(params->next_upload_id_marker.data), K(params->next_upload_id_marker.len));
+        } else if (OB_ISNULL(next_key_marker =
             apr_psprintf(oss_base.aos_pool_, "%.*s",
                          params->next_key_marker.len,
                          params->next_key_marker.data))) {
@@ -1961,7 +2001,7 @@ int ObStorageOssAppendWriter::write(const char *buf,
   if (!is_inited()) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "oss client not inited", K(ret));
-  } else if(NULL == buf || size <= 0) {
+  } else if (NULL == buf || size <= 0) {
     ret = OB_INVALID_ARGUMENT;
     OB_LOG(WARN, "buf is NULL or size is invalid", KP(buf), K(size), K(ret));
   } else if (OB_FAIL(do_write(buf, size, fake_offset, is_pwrite))) {
@@ -1979,7 +2019,7 @@ int ObStorageOssAppendWriter::pwrite(const char *buf, const int64_t size, const
   if (!is_inited()) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "oss client not inited", K(ret));
-  } else if(NULL == buf || size <= 0 || offset < 0) {
+  } else if (NULL == buf || size <= 0 || offset < 0) {
     ret = OB_INVALID_ARGUMENT;
     OB_LOG(WARN, "invalid arguments", KP(buf), K(size), K(ret), K(offset));
   } else if (OB_FAIL(do_write(buf, size, offset, is_pwrite))) {
@@ -2007,7 +2047,7 @@ int ObStorageOssAppendWriter::do_write(const char *buf, const int64_t size, cons
   if (!is_inited()) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "oss client not inited", K(ret));
-  } else if(NULL == buf || size <= 0) {
+  } else if (NULL == buf || size <= 0) {
     ret = OB_INVALID_ARGUMENT;
     OB_LOG(WARN, "buf is NULL or size is invalid", KP(buf), K(size), K(ret));
   } else {
@@ -2027,10 +2067,10 @@ int ObStorageOssAppendWriter::do_write(const char *buf, const int64_t size, cons
     aos_buf_t *content = NULL;
     aos_list_init(&buffer);
     int64_t position = 0;
-    if(OB_ISNULL(headers1 = aos_table_make(aos_pool_, 0))) {
+    if (OB_ISNULL(headers1 = aos_table_make(aos_pool_, 0))) {
       ret = OB_OSS_ERROR;
       OB_LOG(WARN, "fail to make apr table", K(ret));
-    } else if(OB_ISNULL(aos_ret = oss_head_object(oss_option_, &bucket, &object, headers1, &resp_headers))) {
+    } else if (OB_ISNULL(aos_ret = oss_head_object(oss_option_, &bucket, &object, headers1, &resp_headers))) {
       print_oss_info(resp_headers, aos_ret, ret);
       ret = OB_OSS_ERROR;
       OB_LOG(WARN, "oss head object fail", K(ret), K_(bucket), K_(object), K(aos_ret));
@@ -2066,7 +2106,7 @@ int ObStorageOssAppendWriter::do_write(const char *buf, const int64_t size, cons
       }
 
       if (OB_SUCC(ret)) {
-        if(OB_ISNULL(headers2 = aos_table_make(aos_pool_, AOS_TABLE_INIT_SIZE))) {
+        if (OB_ISNULL(headers2 = aos_table_make(aos_pool_, AOS_TABLE_INIT_SIZE))) {
           ret = OB_OSS_ERROR;
           OB_LOG(WARN, "fail to make apr table", K(ret));
         } else if (OB_ISNULL(content = aos_buf_pack(aos_pool_, buf, static_cast<int32_t>(size)))) {
@@ -2194,10 +2234,10 @@ int ObStorageOssWriter::write(const char *buf, const int64_t size)
   if (OB_UNLIKELY(!is_opened_)) {
     ret = OB_NOT_INIT;
     OB_LOG(WARN, "oss writer not opened", K(ret));
-  } else if(OB_ISNULL(buf) || OB_UNLIKELY(size < 0)) {
+  } else if (OB_ISNULL(buf) || OB_UNLIKELY(size < 0)) {
     ret = OB_INVALID_ARGUMENT;
     OB_LOG(WARN, "buf is NULL or size is invalid", KP(buf), K(size), K(ret));
-  }  else {
+  } else {
     aos_string_t bucket;
     aos_string_t object;
     aos_str_set(&bucket, bucket_.ptr());