@@ -38,7 +38,7 @@ from cpython.buffer cimport (
 from cpython.bytes cimport PyBytes_FromStringAndSize
 from libc.stdint cimport uint32_t
 from libc.stdlib cimport free, malloc
-from libc.string cimport memcmp
+from libc.string cimport memcmp, memcpy
 
 import warnings
 
@@ -299,12 +299,10 @@ cdef class SpecializationConstant:
       integers, the first argument is interpreted as the number of bytes and
       the second argument is interpreted as a pointer to the data.
 
-    Note that when constructing from a buffer, the
-    :class:`.SpecializationConstant`, shares memory with the original object.
-    Modifications to the original object's data after construction will be
-    reflected when the :class:`.SpecializationConstant` is used to create a
-    :class:`.SyclKernelBundle`. This is not the case when constructing from a
-    raw pointer, as the data is copied.
+    Note that construction of the :class:`.SpecializationConstant` copies the
+    input, so modifications made after construction of the
+    :class:`.SpecializationConstant` will not be reflected in the
+    :class:`.SyclKernelBundle`.
 
     Args:
         spec_id (int):
@@ -320,11 +318,12 @@ cdef class SpecializationConstant:
     """
 
     cdef _spec_const _spec_const
-    cdef Py_buffer _buffer
 
     def __cinit__(self, spec_id, *args):
         cdef int ret_code = 0
         cdef object target_obj = None
+        cdef Py_buffer _local_buffer
+        cdef void *copied_data
 
         if not isinstance(spec_id, numbers.Integral):
             raise TypeError(
@@ -349,16 +348,16 @@ cdef class SpecializationConstant:
                 )
             elif isinstance(args[0], str):
                 target_obj = np.ascontiguousarray(args[1], dtype=args[0])
+            else:
+                raise TypeError(
+                    "Invalid arguments."
+                )
 
         elif len(args) == 1:
             target_obj = args[0]
             if not PyObject_CheckBuffer(target_obj):
                 # attempt to coerce to a numpy array
                 target_obj = np.ascontiguousarray(target_obj)
-        else:
-            raise TypeError(
-                "Invalid arguments."
-            )
 
         if isinstance(target_obj, np.ndarray):
             if target_obj.dtype.kind not in ("b", "i", "u", "f", "c"):
@@ -373,17 +372,30 @@ cdef class SpecializationConstant:
                 )
 
         ret_code = PyObject_GetBuffer(
-            target_obj, &(self._buffer), PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS
+            target_obj, &(_local_buffer), PyBUF_SIMPLE | PyBUF_ANY_CONTIGUOUS
         )
         if ret_code != 0:
             raise ValueError(
                 "Failed to get buffer view for the provided object."
             )
-        self._spec_const.value = <void*>self._buffer.buf
-        self._spec_const.size = <size_t>self._buffer.len
+
+        self._spec_const.size = <size_t>_local_buffer.len
+        copied_data = malloc(self._spec_const.size)
+
+        if copied_data == NULL:
+            PyBuffer_Release(&(_local_buffer))
+            raise MemoryError(
+                "Failed to allocate memory for specialization constant data."
+            )
+
+        memcpy(copied_data, _local_buffer.buf, self._spec_const.size)
+        self._spec_const.value = copied_data
+
+        PyBuffer_Release(&(_local_buffer))
 
     def __dealloc__(self):
-        PyBuffer_Release(&(self._buffer))
+        if self._spec_const.value != NULL:
+            free(<void*>self._spec_const.value)
 
     def __repr__(self):
         return f"SpecializationConstant({self._spec_const.id})"
 
@@ -106,6 +106,11 @@ def parse_spirv_specializations(
 
         if word_count == 0:
             raise ValueError(f"Invalid SPIR-V instruction at word index {i}")
+        if i + word_count > len(words):
+            raise ValueError(
+                f"Invalid SPIR-V instruction at offset {i} (extends beyond "
+                "buffer)"
+            )
 
         if opcode == SpirvOpCode.OpFunction:
             # everything following is not relevant to specialization constant
@@ -173,12 +178,14 @@ def parse_spirv_specializations(
         dtype_str = type_info["dtype"]
         raw_default = defaults.get(target_id)
         default_value = None
-        if isinstance(raw_default, bytes):
+        if isinstance(raw_default, bool):
+            default_value = raw_default
+        elif isinstance(raw_default, bytes) and dtype_str != "unknown_type":
             try:
                 default_value = np.frombuffer(raw_default, dtype=dtype_str)[
                     0
                 ].item()
-            except Exception:
+            except (ValueError, TypeError):
                 default_value = None
 
         result.append(
 
@@ -503,7 +503,6 @@ _CreateKernelBundleWithIL_ze_impl(const context &SyclCtx,
     backend_traits<ze_be>::return_type<device> ZeDevice;
     ZeDevice = get_native<ze_be>(SyclDev);
 
-    // Specialization constants are not supported by DPCTL at the moment
     std::vector<std::uint32_t> spec_ids;
     std::vector<const void *> spec_values;